⚡️ Speed up function _is_inside_lambda by 17% in PR #1580 (fix/java-direct-jvm-and-bugs)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #1580

If you approve this dependent PR, these changes will be merged into the original PR branch fix/java-direct-jvm-and-bugs.

This PR will be automatically closed if the original PR is merged.

---

📄 17% (0.17x) speedup for _is_inside_lambda in codeflash/languages/java/instrumentation.py

⏱️ Runtime : 1.05 milliseconds → 894 microseconds (best of 34 runs)

📝 Explanation and details

The optimization achieves a 17% runtime improvement (from 1.05ms to 894μs) by caching the current.type attribute access in a local variable (t or current_type) inside the loop. This seemingly small change reduces repeated attribute lookups on the same object during each iteration.

What Changed:
Instead of accessing current.type twice per iteration (once for each conditional check), the optimized version stores it in a local variable and reuses that value. This transforms two attribute lookups into one per iteration.

Why This Improves Performance:
In Python, attribute access involves dictionary lookups in the object's __dict__, which carries overhead. By caching the attribute value in a local variable, the code performs this lookup once per iteration instead of twice. Local variable access in Python is significantly faster than attribute access because it's a simple array index operation at the bytecode level (LOAD_FAST) versus a dictionary lookup (LOAD_ATTR).

Key Performance Characteristics:
The line profiler shows the optimization is particularly effective for the common case where both conditions need to be checked. The time spent on the two conditional checks decreased from 28% + 23.4% = 51.4% of total time to 22.4% + 15.3% = 37.7%, demonstrating measurable savings from the reduced attribute access overhead.

Test Case Performance:

• The optimization shows the most significant gains in large-scale traversal scenarios (1000-node chains), with 4-5% speedups in test_long_chain_with_lambda_at_top_large_scale and test_long_chain_with_method_declaration_earlier_large_scale
• Shorter chains show slight regressions (1-6% slower) in individual test cases, likely due to measurement noise and the overhead of the additional variable assignment being more noticeable in very short executions
• The overall 17% improvement across the full workload confirms the optimization is beneficial when amortized across realistic usage patterns with varying tree depths

This optimization is particularly valuable when traversing deep AST structures, where the function may iterate many times before finding a lambda or method declaration, making the cumulative savings from reduced attribute access substantial.

✅ Correctness verification report:

Test	Status
⚙️ Existing Unit Tests	🔘 None Found
🌀 Generated Regression Tests	✅ 2030 Passed
⏪ Replay Tests	🔘 None Found
🔎 Concolic Coverage Tests	🔘 None Found
📊 Tests Coverage	100.0%

🌀 Click to see Generated Regression Tests

from __future__ import annotations

from typing import Any

# imports
import pytest  # used for our unit tests
from codeflash.languages.java.instrumentation import _is_inside_lambda

# unit tests

# NOTE:
# The original function expects "node" objects that have a `.parent` attribute
# and that each parent has a `.type` attribute. For the purposes of unit
# testing we construct simple, real Python objects that expose these
# attributes. These are not mocks; they are concrete instances created with
# a minimal constructor to emulate the necessary attributes the function
# accesses. Each test is deterministic and documents the intent.

class _TestNode:
    """A minimal, real class to emulate tree-sitter nodes for testing.

    Instances have two attributes:
      - type: any value representing the node type (typically a string)
      - parent: another _TestNode instance or None
    """
    def __init__(self, type_value, parent=None):
        # store the node type (could be string, None, number, etc.)
        self.type = type_value
        # parent is another node instance or None to represent root
        self.parent = parent

def test_immediate_parent_is_lambda():
    # Create a parent node whose type is "lambda_expression"
    parent = _TestNode("lambda_expression", parent=None)
    # Create a child node whose parent is the lambda node
    child = _TestNode("some_node", parent=parent)
    # The child is directly inside a lambda -> should return True
    codeflash_output = _is_inside_lambda(child) # 711ns -> 721ns (1.39% slower)

def test_grandparent_is_lambda():
    # Create a lambda grandparent
    grandparent = _TestNode("lambda_expression", parent=None)
    # Middle node between child and lambda
    parent = _TestNode("block", parent=grandparent)
    child = _TestNode("identifier", parent=parent)
    # The child has a grandparent which is a lambda -> should return True
    codeflash_output = _is_inside_lambda(child) # 762ns -> 892ns (14.6% slower)

def test_encounter_method_declaration_before_lambda_returns_false():
    # Construct a chain where a method_declaration appears before a lambda
    lambda_node = _TestNode("lambda_expression", parent=None)
    # method_declaration is above the lambda in this chain
    method = _TestNode("method_declaration", parent=lambda_node)
    parent = _TestNode("some_block", parent=method)
    child = _TestNode("leaf", parent=parent)
    # The traversal will hit method_declaration before reaching the lambda -> False
    codeflash_output = _is_inside_lambda(child) # 772ns -> 812ns (4.93% slower)

def test_no_lambda_in_ancestors_returns_false():
    # Chain with various node types but no lambda or method_declaration
    root = _TestNode("compilation_unit", parent=None)
    a = _TestNode("class_declaration", parent=root)
    b = _TestNode("member", parent=a)
    c = _TestNode("statement", parent=b)
    child = _TestNode("expression", parent=c)
    # No lambda_expression ancestor, so should return False
    codeflash_output = _is_inside_lambda(child) # 1.06μs -> 1.08μs (1.85% slower)

def test_parent_is_none_returns_false():
    # Node whose parent is None (top-level node)
    node = _TestNode("some_top_level_node", parent=None)
    # There are no ancestors -> should return False
    codeflash_output = _is_inside_lambda(node) # 471ns -> 500ns (5.80% slower)

def test_types_other_than_string_are_handled_gracefully():
    # Use non-string types for .type attributes, e.g., integers and None.
    root = _TestNode(None, parent=None)  # type is None
    mid = _TestNode(123, parent=root)    # type is integer
    child = _TestNode("leaf", parent=mid)
    # None and integers will never equal "lambda_expression" or "method_declaration"
    codeflash_output = _is_inside_lambda(child) # 1.06μs -> 1.11μs (4.50% slower)

def test_lambda_at_root_is_detected():
    # Root itself is a lambda_expression; a child should detect it
    root_lambda = _TestNode("lambda_expression", parent=None)
    child = _TestNode("body", parent=root_lambda)
    # Should return True because an ancestor (the root) is a lambda
    codeflash_output = _is_inside_lambda(child) # 521ns -> 551ns (5.44% slower)

def test_immediate_parent_is_method_declaration_returns_false():
    # If the immediate parent is method_declaration, function should return False
    method_parent = _TestNode("method_declaration", parent=None)
    child = _TestNode("param", parent=method_parent)
    codeflash_output = _is_inside_lambda(child) # 551ns -> 591ns (6.77% slower)

def test_deep_chain_with_method_declaration_then_lambda_stops_at_method():
    # Build a deep chain: child -> ... -> method_declaration -> ... -> lambda
    lambda_top = _TestNode("lambda_expression", parent=None)
    above_lambda = _TestNode("wrapper", parent=lambda_top)
    method = _TestNode("method_declaration", parent=above_lambda)  # method above lambda
    mid = _TestNode("block", parent=method)
    child = _TestNode("expr", parent=mid)
    # Should return False because method_declaration is encountered before lambda
    codeflash_output = _is_inside_lambda(child) # 812ns -> 861ns (5.69% slower)

def test_long_chain_with_lambda_at_top_large_scale():
    # Build a long chain (1000 nodes) with the topmost being a lambda_expression.
    chain_length = 1000
    top = _TestNode("lambda_expression", parent=None)  # topmost node is lambda
    # Build downwards so that bottom_node is the deepest child
    current = top
    for i in range(chain_length):
        # create intermediate nodes with arbitrary types
        current = _TestNode(f"node_{i}", parent=current)
    bottom_node = current
    # The bottom node has the lambda_expression ancestor at the top -> True
    codeflash_output = _is_inside_lambda(bottom_node) # 38.9μs -> 37.2μs (4.43% faster)

def test_long_chain_with_method_declaration_earlier_large_scale():
    # Build a long chain where a method_declaration appears early and should short-circuit.
    chain_length = 1000
    # Build tail nodes after the method_declaration
    tail = None
    for i in range(10):  # small tail
        tail = _TestNode(f"tail_{i}", parent=tail)
    # method_declaration that should cause a False regardless of higher lambdas
    method = _TestNode("method_declaration", parent=None)
    # Attach the tail under the method
    current = tail
    # If tail is None, set method as parent; otherwise walk to attach properly
    if current is not None:
        # find the bottom of tail (the last created), attach it under method
        # we created tail in a way that tail is the last created and its parent is previous,
        # but to make bottom node have method as ancestor we need to set the topmost parent's parent:
        # simplest approach: create a new node whose parent is method and then a long chain below it
        current = _TestNode("attach_point", parent=method)
        # build many nodes below attach_point
        for i in range(chain_length):
            current = _TestNode(f"deep_{i}", parent=current)
    else:
        # If tail creation produced None (shouldn't happen), just create a deep chain with method at top
        current = method
        for i in range(chain_length):
            current = _TestNode(f"deep_{i}", parent=current)
    bottom = current
    # Now add a lambda above the method to ensure it would be ignored because the method appears first
    top_lambda = _TestNode("lambda_expression", parent=None)
    # Attach method above the lambda (i.e., method.parent -> lambda)
    method.parent = top_lambda
    # Even though lambda exists above method, encountering method_declaration should stop traversal -> False
    codeflash_output = _is_inside_lambda(bottom) # 37.6μs -> 35.9μs (5.00% faster)

def test_many_repeated_calls_are_deterministic_and_fast():
    # Create two small chains: one that should be True, one False
    true_chain = _TestNode("lambda_expression", parent=None)
    true_chain = _TestNode("mid", parent=true_chain)
    true_chain = _TestNode("leaf", parent=true_chain)

    false_chain = _TestNode("method_declaration", parent=None)
    false_chain = _TestNode("mid", parent=false_chain)
    false_chain = _TestNode("leaf", parent=false_chain)

    # Call the function repeatedly (1000 iterations) to check deterministic behavior
    for _ in range(1000):
        codeflash_output = _is_inside_lambda(true_chain) # 221μs -> 224μs (1.40% slower)
        codeflash_output = _is_inside_lambda(false_chain)
# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

To edit these changes git checkout codeflash/optimize-pr1580-2026-02-20T09.12.25 and push.

[claude]

PR Review Summary

Prek Checks

✅ All checks passed (ruff check + ruff format). No fixes needed.

Mypy

✅ No type errors found in codeflash/languages/java/instrumentation.py.

Code Review

✅ No critical issues found.

The change is a straightforward micro-optimization that caches current.type in a local variable t to avoid repeated attribute lookups in the _is_inside_lambda loop. Logic is unchanged — the function behaves identically to the original.

Test Coverage

File	Stmts (base)	Stmts (PR)	Miss	Coverage (base)	Coverage (PR)	Δ
codeflash/languages/java/instrumentation.py	508	509	92	82%	82%	0%

• Changed lines (87–91): ✅ Covered by tests
• Line 93 (return False at end of function): Not covered — same as base branch
• No coverage regression

---

Last updated: 2026-02-20