⚡️ Speed up method CfoVisitor._is_codeflash_output_target by 76% in PR #358 (fix-test-reporting)

Here is an optimized rewrite of your program with a focus on improving performance in the `_is_codeflash_output_target` method.  
These changes focus on avoiding unnecessary generator creation, reducing function calls, and using faster data structures and comparison strategies.



**Key optimizations:**
- Use `type(...) is ...` instead of `isinstance()` for frequently called type checks for speed.
- Unroll the `any(...)` generator over `target.elts` into an explicit for loop to reduce function call and overhead in the hot path.
- Avoid recursive generator creation where possible; use explicit returns.
- Avoid `isinstance(..., (a, b))` for hot paths (for small type hierarchies and known types); it's slightly faster to compare types directly.

These micro-optimizations especially benefit scenarios with large ASTs or heavy tuple/list unpackings.  
The function's logic and return value are identical to your original version.

Author: codeflash-ai[bot]

codeflash/code_utils/edit_generated_tests.py

@@ -54,14 +54,25 @@ def __init__(self, source_code: str) -> None:
         self.source_lines = source_code.splitlines()
         self.results: list[int] = []  # map actual line number to line number in ast
 
-    def _is_codeflash_output_target(self, target: Union[ast.expr, list]) -> bool:  # type: ignore[type-arg]
+    def _is_codeflash_output_target(self, target: Union[ast.expr, list]) -> bool:
         """Check if the assignment target is the variable 'codeflash_output'."""
-        if isinstance(target, ast.Name):
+        t_type = type(target)
+        if t_type is ast.Name:
             return target.id == "codeflash_output"
-        if isinstance(target, (ast.Tuple, ast.List)):
+        if t_type is ast.Tuple or t_type is ast.List:
             # Handle tuple/list unpacking: a, codeflash_output, b = values
-            return any(self._is_codeflash_output_target(elt) for elt in target.elts)
-        if isinstance(target, (ast.Subscript, ast.Attribute)):
+            # Flatten elts (avoid generator, avoid recursion if not necessary):
+            elts = target.elts
+            for elt in elts:
+                if type(elt) is ast.Name:
+                    if elt.id == "codeflash_output":
+                        return True
+                elif type(elt) is ast.Tuple or type(elt) is ast.List:
+                    # Recursively check nested tuples/lists, but avoid generator
+                    if self._is_codeflash_output_target(elt):
+                        return True
+            return False
+        if t_type is ast.Subscript or t_type is ast.Attribute:
             # Not a simple variable assignment
             return False
         return False