⚡️ Speed up function function_is_a_property by 11% in PR #970 (ranking-changes)

[codeflash-ai]

⚡️ This pull request contains optimizations for PR #970

If you approve this dependent PR, these changes will be merged into the original PR branch ranking-changes.

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

---

📄 11% (0.11x) speedup for function_is_a_property in codeflash/discovery/functions_to_optimize.py

⏱️ Runtime : 1.13 milliseconds → 1.02 milliseconds (best of 90 runs)

📝 Explanation and details

The optimization achieves an 11% speedup through two key changes:

1. Constant Hoisting: The original code repeatedly assigns property_id = "property" and ast_name = ast.Name on every function call. The optimized version moves these to module-level constants _property_id and _ast_name, eliminating 4,130 redundant assignments per profiling run (saving ~2.12ms total time).

2. isinstance() vs type() comparison: Replaced type(node) is ast_name with isinstance(node, _ast_name). While both are correct for AST nodes (which use single inheritance), isinstance() is slightly more efficient for type checking in Python's implementation.

Performance Impact: The function is called in AST traversal loops when discovering functions to optimize (visit_FunctionDef and visit_AsyncFunctionDef). Since these visitors process entire codebases, the 11% per-call improvement compounds significantly across large projects.

Test Case Performance: The optimization shows consistent gains across all test scenarios:

• Simple cases (no decorators): 29-42% faster due to eliminated constant assignments
• Property detection cases: 11-26% faster from combined optimizations
• Large-scale tests (500-1000 functions): 18.5% faster, demonstrating the cumulative benefit when processing many functions

The optimizations are particularly effective for codebases with many function definitions, where this function gets called repeatedly during AST analysis.

✅ Correctness verification report:

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

🌀 Generated Regression Tests and Runtime

from __future__ import annotations

import ast

# imports
from codeflash.discovery.functions_to_optimize import function_is_a_property

# unit tests

# --- Basic Test Cases ---


def test_no_decorators_returns_false():
    # Function with no decorators should not be a property
    node = ast.parse("def foo(self): pass").body[0]
    codeflash_output = not function_is_a_property(node)  # 742ns -> 521ns (42.4% faster)


def test_single_property_decorator():
    # Function with @property decorator should be detected as property
    node = ast.parse("@property\ndef foo(self): pass").body[0]
    codeflash_output = function_is_a_property(node)  # 882ns -> 791ns (11.5% faster)


def test_multiple_decorators_including_property():
    # Function with multiple decorators, one of which is @property
    src = "@classmethod\n@property\ndef foo(cls): pass"
    node = ast.parse(src).body[0]
    codeflash_output = function_is_a_property(node)  # 1.00μs -> 912ns (9.87% faster)


def test_multiple_decorators_without_property():
    # Function with multiple decorators, none are @property
    src = "@classmethod\n@staticmethod\ndef foo(cls): pass"
    node = ast.parse(src).body[0]
    codeflash_output = not function_is_a_property(node)  # 982ns -> 811ns (21.1% faster)


def test_async_function_with_property():
    # Async function with @property decorator
    src = "@property\nasync def foo(self): pass"
    node = ast.parse(src).body[0]
    codeflash_output = function_is_a_property(node)  # 861ns -> 681ns (26.4% faster)


# --- Edge Test Cases ---


def test_decorator_is_attribute_not_name():
    # Function with @something.property should NOT be detected as property
    src = "@something.property\ndef foo(self): pass"
    node = ast.parse(src).body[0]
    # The decorator is ast.Attribute, not ast.Name
    codeflash_output = not function_is_a_property(node)  # 722ns -> 701ns (3.00% faster)


def test_decorator_is_call_not_name():
    # Function with @property() (called) should NOT be detected as property
    src = "@property()\ndef foo(self): pass"
    node = ast.parse(src).body[0]
    # The decorator is ast.Call, not ast.Name
    codeflash_output = not function_is_a_property(node)  # 731ns -> 711ns (2.81% faster)


def test_decorator_is_property_case_sensitive():
    # Function with @Property (capital P) should NOT be detected as property
    src = "@Property\ndef foo(self): pass"
    node = ast.parse(src).body[0]
    codeflash_output = not function_is_a_property(node)  # 931ns -> 832ns (11.9% faster)


def test_decorator_is_property_with_alias():
    # Function with @prop (aliased property) should NOT be detected as property
    src = "prop = property\n@prop\ndef foo(self): pass"
    node = ast.parse(src).body[1]
    codeflash_output = not function_is_a_property(node)  # 1.07μs -> 881ns (21.7% faster)


def test_decorator_is_property_in_a_class():
    # Function with @property inside a class
    src = "class C:\n    @property\n    def foo(self): pass"
    node = ast.parse(src).body[0].body[0]
    codeflash_output = function_is_a_property(node)  # 891ns -> 761ns (17.1% faster)


def test_decorator_list_is_empty():
    # Defensive: decorator_list is empty
    node = ast.parse("def foo(): pass").body[0]
    node.decorator_list = []
    codeflash_output = not function_is_a_property(node)  # 641ns -> 501ns (27.9% faster)


def test_function_with_nonstandard_ast_node():
    # Defensive: decorator_list contains non-ast.Name node
    src = "@classmethod\ndef foo(cls): pass"
    node = ast.parse(src).body[0]
    codeflash_output = not function_is_a_property(node)  # 902ns -> 741ns (21.7% faster)


# --- Large Scale Test Cases ---


def test_many_functions_with_and_without_property():
    # Generate 500 functions, half with @property, half without
    src = "\n".join(
        (f"@property\ndef foo{i}(self): pass" if i % 2 == 0 else f"def foo{i}(self): pass") for i in range(1000)
    )
    mod = ast.parse(src)
    for i, node in enumerate(mod.body):
        if i % 2 == 0:
            codeflash_output = function_is_a_property(node)
        else:
            codeflash_output = not function_is_a_property(node)


def test_many_decorators_on_many_functions():
    # Generate 100 functions, each with 10 decorators, only one is @property
    src = "\n".join(
        (
            "".join(f"@decorator{j}\n" for j in range(5))
            + "@property\n"
            + "".join(f"@decorator{j}\n" for j in range(5, 10))
            + f"def foo{i}(self): pass"
        )
        for i in range(100)
    )
    mod = ast.parse(src)
    for node in mod.body:
        codeflash_output = function_is_a_property(node)  # 76.8μs -> 73.1μs (5.08% faster)


def test_large_number_of_functions_without_property():
    # 1000 functions, none with @property
    src = "\n".join(f"def foo{i}(self): pass" for i in range(1000))
    mod = ast.parse(src)
    for node in mod.body:
        codeflash_output = not function_is_a_property(node)  # 267μs -> 225μs (18.5% faster)


# codeflash_output is used to check that the output of the original code is the same as that of the optimized code.

from __future__ import annotations

import ast

# imports
from codeflash.discovery.functions_to_optimize import function_is_a_property

# unit tests


# Helper to parse a function from source and return the ast.FunctionDef/AsyncFunctionDef node
def get_func_node(source: str):
    """Parse the source and return the first FunctionDef or AsyncFunctionDef node."""
    module = ast.parse(source)
    for node in module.body:
        if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
            return node
    raise ValueError("No function definition found in source.")


# 1. Basic Test Cases


def test_plain_function_no_decorators():
    """Function with no decorators should return False."""
    src = "def foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 662ns -> 511ns (29.5% faster)


def test_function_with_property_decorator():
    """Function with @property decorator should return True."""
    src = "@property\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 861ns -> 711ns (21.1% faster)


def test_function_with_other_decorator():
    """Function with a non-property decorator should return False."""
    src = "@staticmethod\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 802ns -> 712ns (12.6% faster)


def test_function_with_property_and_other_decorator():
    """Function with @property and another decorator should return True."""
    src = "@staticmethod\n@property\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 951ns -> 822ns (15.7% faster)


def test_async_function_with_property():
    """Async function with @property should return True."""
    src = "@property\nasync def foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 762ns -> 651ns (17.1% faster)


# 2. Edge Test Cases


def test_function_with_property_as_attribute():
    """@something.property should NOT be considered as @property."""
    src = "@something.property\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 731ns -> 681ns (7.34% faster)


def test_function_with_property_as_call():
    """@property() is not the same as @property, should be False."""
    src = "@property()\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 702ns -> 651ns (7.83% faster)


def test_function_with_property_in_middle():
    """Function with multiple decorators, property in the middle."""
    src = "@classmethod\n@property\n@another\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 942ns -> 892ns (5.61% faster)


def test_function_with_multiple_properties():
    """Function with multiple @property decorators (nonsensical, but test anyway)."""
    src = "@property\n@property\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 822ns -> 671ns (22.5% faster)


def test_function_with_property_as_alias():
    """Function with decorator named 'property' but imported as alias (should be True if ast.Name)."""
    src = "property = staticmethod\n@property\ndef foo(self):\n    pass"
    node = get_func_node(src)
    # The decorator is still 'property' as ast.Name
    codeflash_output = function_is_a_property(node)  # 781ns -> 591ns (32.1% faster)


def test_function_with_property_as_attribute_of_module():
    """@module.property should not be considered as @property."""
    src = "@module.property\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 711ns -> 701ns (1.43% faster)


def test_function_with_property_and_args():
    """@property(something) is not a plain @property."""
    src = "@property('foo')\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 711ns -> 691ns (2.89% faster)


def test_function_with_no_decorator_list():
    """Manually create a FunctionDef with empty decorator_list."""
    node = ast.FunctionDef(
        name="foo",
        args=ast.arguments(posonlyargs=[], args=[], kwonlyargs=[], kw_defaults=[], defaults=[]),
        body=[],
        decorator_list=[],
        returns=None,
        type_comment=None,
    )
    codeflash_output = function_is_a_property(node)  # 741ns -> 561ns (32.1% faster)


def test_function_with_non_name_decorator():
    """Decorator is a Call node, not ast.Name."""
    src = "@decorator()\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 811ns -> 751ns (7.99% faster)


def test_function_with_property_case_sensitive():
    """Decorator named 'Property' (capital P) should not match."""
    src = "@Property\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 842ns -> 751ns (12.1% faster)


def test_async_function_with_no_decorators():
    """Async function with no decorators should return False."""
    src = "async def foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 622ns -> 471ns (32.1% faster)


# 3. Large Scale Test Cases


def test_many_functions_one_property():
    """Test a module with many functions, only one has @property."""
    funcs = []
    for i in range(999):
        funcs.append(f"def foo{i}(self):\n    pass")
    funcs.append("@property\ndef bar(self):\n    pass")
    src = "\n".join(funcs)
    module = ast.parse(src)
    found = False
    for node in module.body:
        if isinstance(node, ast.FunctionDef) and function_is_a_property(node):
            found = True


def test_many_functions_all_property():
    """Test a module with many functions, all with @property."""
    funcs = [f"@property\ndef foo{i}(self):\n    pass" for i in range(500)]
    src = "\n".join(funcs)
    module = ast.parse(src)
    count = 0
    for node in module.body:
        if isinstance(node, ast.FunctionDef):
            codeflash_output = function_is_a_property(node)
            count += 1


def test_many_functions_no_property():
    """Test a module with many functions, none with @property."""
    funcs = [f"def foo{i}(self):\n    pass" for i in range(500)]
    src = "\n".join(funcs)
    module = ast.parse(src)
    count = 0
    for node in module.body:
        if isinstance(node, ast.FunctionDef):
            codeflash_output = function_is_a_property(node)
            count += 1


def test_large_decorator_list_property_at_end():
    """Function with many decorators, @property at the end."""
    decorators = "\n".join([f"@dec{i}" for i in range(998)]) + "\n@property"
    src = f"{decorators}\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 66.4μs -> 72.2μs (8.02% slower)


def test_large_decorator_list_no_property():
    """Function with many decorators, none are @property."""
    decorators = "\n".join([f"@dec{i}" for i in range(999)])
    src = f"{decorators}\ndef foo(self):\n    pass"
    node = get_func_node(src)
    codeflash_output = function_is_a_property(node)  # 67.8μs -> 75.4μs (10.0% slower)


# 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-pr970-2025-12-17T22.45.08 and push.