Enabling Nested Functions' Linkage

[JayGhiya]

🎉 New Feature: Nested Function Call Detection in Python Analysis

We're excited to announce a new feature in Code Confluence that brings deeper understanding to Python codebases: Nested Function Detection!

What's New?

The ability to identify, track, and link nested functions in Python code! Python developers often use nested functions to encapsulate logic, create closures, and implement elegant patterns. Now, our codebase understanding tools can properly analyze these relationships.

Why It Matters

Nested functions (functions defined inside other functions) play a vital role in Python programming but can be challenging to analyze:

• They create scoping relationships that affect variable access
• They enable powerful design patterns like decorators and callbacks
• They often contain important business logic that's tightly coupled to their parent context

By properly linking nested functions to their parents, we can:

• Create more accurate call graphs
• Better visualize code structure
• Provide more precise code navigation
• Enhance documentation generation with context-aware insights

How It Works

Under the hood, we're using Tree-sitter grammar queries to analyze function definitions and identify parent-child relationships. When a nested function is found, we set the parent_function_name field in the UnoplatChapiForgeFunction object, pointing to the qualified name of its parent.

Here's a simple example:

def outer_function(name: str) -> str:
    def inner_function() -> str:
        return "Hello"
    greeting = inner_function()
    return f"{greeting}, {name}!"

Before this feature:

outer_function: parent_function_name = None
inner_function: parent_function_name = None  # Missing relationship!

After this feature:

outer_function: parent_function_name = None
inner_function: parent_function_name = "module.outer_function"  # ✅ Correct relationship

Supported Scenarios

Our nested function detection works across a wide range of Python coding patterns:

1. Simple Nested Functions

def outer_function(name: str) -> str:
    def inner_function() -> str:
        return "Hello"
    return inner_function() + name

2. Multiple Nested Functions in the Same Parent

def parent_function(x: int, y: int) -> int:
    def nested_func1() -> int:
        return x + y
    
    def nested_func2() -> int:
        return x * y
    
    return nested_func1() + nested_func2()

3. Nested Functions with Decorators

def outer_function() -> str:
    @decorator
    def inner_function() -> str:
        return "Hello"
    
    return inner_function()

4. Multi-level Nested Functions

def level1() -> str:
    def level2() -> str:
        def level3() -> str:
            return "deeply nested"
        return level3()
    return level2()

5. Conditional Nested Function Definitions

def outer(x: int) -> int:
    if x > 0:
        def inner() -> int:
            return x
    else:
        def inner() -> int:
            return -x
    return inner()

6. Nested Functions Within Class Methods

class MyClass:
    def method(self) -> str:
        def inner_function() -> str:
            return "Inside method"
        return inner_function()

Under The Hood

Here's how we're implementing this feature:

1. We parse Python code using Tree-sitter's Abstract Syntax Tree (AST)
2. We identify all function definitions in the file using a specialized query
3. For each function, we check if it's defined within another function's scope
4. When we find a nested function, we set its parent_function_name to the qualified name of its parent

# Example Tree-sitter Query
(function_definition
  name: (identifier) @function.name
  body: (block
    (function_definition
      name: (identifier) @nested_function.name)))

All of this happens without modifying your source code and with minimal performance impact.

Code Journey: From AST to Relationship

Let's walk through a simplified version of how we detect and link nested functions:

1. Parse the File: Convert Python code into a Tree-sitter AST

   tree = tree_sitter.parse(file_content)

2. Extract All Functions: Use a specialized query to find function definitions

   query = """
   (function_definition
     name: (identifier) @function.name) @function.definition
   """
   function_nodes = find_all_function_nodes(tree.root_node, query)

3. Create a Function Map: Build a dictionary mapping function signatures to their objects

   function_map = {}
   for func in functions:
       signature = extract_function_signature(func.Content)
       if signature:
           function_map[signature] = func

4. Identify Parent-Child Relationships: For each function node, check if it's nested

   for node in function_nodes:
       # Get parent function node if it exists
       parent_node = find_parent_function_node(node)
       if parent_node:
           # Link the nested function to its parent
           nested_function = function_map[get_node_signature(node)]
           parent_function = function_map[get_node_signature(parent_node)]
           nested_function.parent_function_name = parent_function.qualified_name

Visualization Impact

This feature enhances our visualizations by properly showing function hierarchies:

Before:

module
├── outer_function
└── inner_function  # Incorrectly shown at same level

After:

module
└── outer_function
    └── inner_function  # Correctly nested

💬 Community Feedback Wanted!

We're excited about this new capability, but we need your feedback! Have you encountered any Python nested function patterns that aren't covered by our implementation? Do you have suggestions for enhancing this feature?

Please share your thoughts, questions, and feedback in the comments section below. Your input will help shape the future of this feature!

Next Steps

We're continuing to enhance our Python code analysis capabilities. Coming soon:

• Improved visualization of nested function relationships
• Better handling of closures and variable capture
• Analysis of function object passing patterns
• Detection of callback patterns and event-driven architectures
• Integration with our code navigation features

Stay tuned for more updates, and happy coding!

Try It Today!

Ready to see nested function relationships in your own codebase? Follow these steps to get started with Unoplat Code Confluence:

check out our Quick Start Guide.

---

Team Code Confluence