Codegen fails to classify FunctionCalls for functions as Class Fields

[JohnPeng47]

So the following case does not seem to get classified as a FunctionCall

            module_cov = module_cov.get_coverage()
            test_result = [StratResult(src_file, self.test_input.path)]
            improved, failed, no_improve = await self.evaluator(  ## <<< does not recognize this as a FunctionCall
                test_result,
                self.test_input,
                module_cov,
                self.test_input.test_file,
                n_times=n_times,
            )

Defined as follows:

        self.strat: BaseStrategy = AUGMENT_STRATS[strat](self.src_repo, self.test_input)
        self.evaluator: Evaluator = AUGMENT_EVALS[evaluator](
            self.repo_name, 
            self.src_repo, 
            self.run_args, 
            test_input, 
            self.run_test,
            use_cache = self.use_cache,
            delete_last = self.delete_last
        )
        self.model_name = model

[bagel897]

Interesting - I'll take a look

[bagel897]

To be clear, you want this to be detected as a usage of this function?
We don't currently support type narrowing - we'd need to account for this code when resolving the definition of that call

if not isinstance(self.evaluator, AugmentAdditiveEvaluator):
    raise Exception(
        f"Expected AugmentAdditiveEvaluator, got {self.evaluator.__class__}"
    )

[JohnPeng47]

That would be great but yeah, kinda of expected you guys to not support it (although plans for future release)? But I was moreso asking about functions that get assigned to method fields and called as such, which does not seem to be registered in the calls either. For example:

class Composer:
    """
    Used to instantiate different combinations of strategies for generating test cases
    """

    def __init__(
        self,
...
        verify: bool = False,
        run_test: Callable = None,
    ):
        self.run_test = run_test

....
            for i in range(n_times):
            src_file = await self._llm_generate_with_retry(prompt, i)

            # this does not get logged
            module_cov = await self.run_test(
                self.repo_name, 
                self.run_args, 
                include_tests=self.test_input,
                patch_file=updated_patchfile,
                use_cache=self.use_cache,
                delete_last=self.delete_last
            )

So I expected to see Composer.run_test in here but its not in the results

(cowboy-server) ubuntu@ip-172-31-37-242:~/cowboy-server$ python test_codegen.py
Func[1]: Composer.gen_test_serial_additive
Func[2]: Composer.__init__
Func[3]: green_text
Func[2]: Composer._llm_generate_with_retry
Func[3]: Composer.__init__
Func[4]: green_text
Func[3]: extract_python_code
Func[3]: Composer.__init__
Func[4]: green_text
Func[3]: CowboyRunTimeException.__init__
Func[2]: Composer.__init__
Func[3]: green_text
Func[2]: Composer.__init__
Func[3]: green_text
Func[2]: StratResult.__call__
Func[2]: Composer.__init__
Func[3]: green_text
Func[2]: Composer.filter_overlap_improvements
Func[2]: Composer.__init__
Func[3]: green_text
Func[2]: PatchFile.__call__
Func[2]: Composer.__init__
Func[3]: green_text
Func[2]: Composer.__init__
Func[3]: green_text
Func[2]: Composer.__init__
Func[3]: green_text
True
True
(cowboy-server) ubuntu@ip-172-31-37-242:~/cowboy-server$

Script to generate this:

import networkx as nx
from codegen.sdk.core.interfaces.callable import FunctionCallDefinition
from codegen.sdk.core.function import Function
from codegen.sdk.python.class_definition import PyClass
from codegen.sdk.core.detached_symbols.function_call import FunctionCall
from codegen.sdk.core.codebase import Codebase, ExternalModule

def create_call_graph(start_func, end_func, max_depth=5):
    G = nx.DiGraph()

    def traverse_calls(parent_func, current_depth):
        if current_depth > max_depth:
            return

        # Determine source node
        if isinstance(parent_func, Function):
            src_call = src_func = parent_func
        else:
            src_func = parent_func.function_definition
            src_call = parent_func

        # Missing definitions for python libs
        if isinstance(src_func, ExternalModule):
            return

        if isinstance(src_func, (Function, FunctionCall)):
            func_name = src_func.name if not src_func.is_method else src_func.parent_class.name + "." + src_func.name
        elif isinstance(src_func, PyClass):
            func_name = src_func.name + ".__call__"
        
        print(f"Func[{current_depth}]: {func_name}")
        
        # Traverse all function calls
        for call in src_func.function_calls:
            func = call.function_definition

            # Error if line not added
            # Missing definitions for python libs
            if not func:
                continue

            # Skip recursive calls
            if func.name == src_func.name:
                continue

            # Add nodes and edges
            G.add_node(call)
            # print("Creating node: ", call)
            G.add_edge(src_call, call)

            # Check if we reached the target
            if func == end_func:
                G.add_edge(call, end_func)
                return

            # Continue traversal
            traverse_calls(call, current_depth + 1)

    # Initialize graph
    G.add_node(start_func, color="blue")  # Start node
    G.add_node(end_func, color="red")     # End node

    # Start traversal
    traverse_calls(start_func, 1)
    return G


codebase = Codebase(".")

# Usage example
py_class = codebase.get_class("Composer")
start = py_class.get_method("gen_test_serial_additive")
py_class2 = codebase.get_class("AugmentAdditiveEvaluator")
end = py_class2.get_method("process_test_results")
if not end:
    print("wtf??")

graph = create_call_graph(start, end)
print(graph.has_node(start))
print(graph.has_node(end))

# # Find longest path in graph
longest_path = None
max_length = 0

# if longest_path:
#     print("Longest path:")
#     for node in longest_path:
#         print(f"  {node}")
# else:
#     print("No path found between start and end nodes")