Merge pull request #1339 from codeflash-ai/coverage-no-files

Skip when no gen tests and no existing tests

Author: KRRT7

codeflash/code_utils/code_extractor.py

@@ -1429,7 +1429,9 @@ def _collect_numerical_imports(tree: ast.Module) -> tuple[set[str], set[str]]:
     numerical_names: set[str] = set()
     modules_used: set[str] = set()
 
-    for node in ast.walk(tree):
+    stack: list[ast.AST] = [tree]
+    while stack:
+        node = stack.pop()
         if isinstance(node, ast.Import):
             for alias in node.names:
                 # import numpy or import numpy as np
@@ -1451,6 +1453,8 @@ def _collect_numerical_imports(tree: ast.Module) -> tuple[set[str], set[str]]:
                         name = alias.asname if alias.asname else alias.name
                         numerical_names.add(name)
                 modules_used.add(module_root)
+        else:
+            stack.extend(ast.iter_child_nodes(node))
 
     return numerical_names, modules_used
 

codeflash/context/code_context_extractor.py

@@ -746,7 +746,11 @@ def get_external_base_class_inits(code_context: CodeStringsMarkdown, project_roo
         return CodeStringsMarkdown(code_strings=[])
 
     imported_names: dict[str, str] = {}
-    external_bases: list[tuple[str, str]] = []
+    # Use a set to deduplicate external base entries to avoid repeated expensive checks/imports.
+    external_bases_set: set[tuple[str, str]] = set()
+    # Local cache to avoid repeated _is_project_module calls for the same module_name.
+    is_project_cache: dict[str, bool] = {}
+
     for node in ast.walk(tree):
         if isinstance(node, ast.ImportFrom) and node.module:
             for alias in node.names:
@@ -763,21 +767,31 @@ def get_external_base_class_inits(code_context: CodeStringsMarkdown, project_roo
 
                 if base_name and base_name in imported_names:
                     module_name = imported_names[base_name]
-                    if not _is_project_module(module_name, project_root_path):
-                        external_bases.append((base_name, module_name))
-
-    if not external_bases:
+                    # Check cache first to avoid repeated expensive checks.
+                    cached = is_project_cache.get(module_name)
+                    if cached is None:
+                        is_project = _is_project_module(module_name, project_root_path)
+                        is_project_cache[module_name] = is_project
+                    else:
+                        is_project = cached
+
+                    if not is_project:
+                        external_bases_set.add((base_name, module_name))
+
+    if not external_bases_set:
         return CodeStringsMarkdown(code_strings=[])
 
     code_strings: list[CodeString] = []
-    extracted: set[tuple[str, str]] = set()
-
-    for base_name, module_name in external_bases:
-        if (module_name, base_name) in extracted:
-            continue
+    # Cache imported modules to avoid repeated importlib.import_module calls.
+    imported_module_cache: dict[str, object] = {}
 
+    for base_name, module_name in external_bases_set:
         try:
-            module = importlib.import_module(module_name)
+            module = imported_module_cache.get(module_name)
+            if module is None:
+                module = importlib.import_module(module_name)
+                imported_module_cache[module_name] = module
+
             base_class = getattr(module, base_name, None)
             if base_class is None:
                 continue
@@ -799,7 +813,6 @@ def get_external_base_class_inits(code_context: CodeStringsMarkdown, project_roo
 
             class_source = f"class {base_name}:\n" + textwrap.indent(init_source, "    ")
             code_strings.append(CodeString(code=class_source, file_path=class_file))
-            extracted.add((module_name, base_name))
 
         except (ImportError, ModuleNotFoundError, AttributeError):
             logger.debug(f"Failed to extract __init__ for {module_name}.{base_name}")
@@ -854,12 +867,13 @@ def extract_imports_for_class(module_tree: ast.Module, class_node: ast.ClassDef,
                 needed_names.add(decorator.func.value.id)
 
     # Get type annotation names from class body (for dataclass fields)
-    for item in ast.walk(class_node):
+    for item in class_node.body:
         if isinstance(item, ast.AnnAssign) and item.annotation:
             collect_names_from_annotation(item.annotation, needed_names)
         # Also check for field() calls which are common in dataclasses
-        if isinstance(item, ast.Call) and isinstance(item.func, ast.Name):
-            needed_names.add(item.func.id)
+        elif isinstance(item, ast.Assign) and isinstance(item.value, ast.Call):
+            if isinstance(item.value.func, ast.Name):
+                needed_names.add(item.value.func.id)
 
     # Find imports that provide these names
     import_lines: list[str] = []

codeflash/discovery/discover_unit_tests.py

@@ -656,7 +656,7 @@ def discover_unit_tests(
 
     # Existing Python logic
     framework_strategies: dict[str, Callable] = {"pytest": discover_tests_pytest, "unittest": discover_tests_unittest}
-    strategy = framework_strategies.get(cfg.test_framework, None)
+    strategy = framework_strategies.get(cfg.test_framework)
     if not strategy:
         error_message = f"Unsupported test framework: {cfg.test_framework}"
         raise ValueError(error_message)

codeflash/github/PrComment.py

@@ -25,11 +25,11 @@ class PrComment:
     best_async_throughput: Optional[int] = None
 
     def to_json(self) -> dict[str, Union[str, int, dict[str, dict[str, int]], list[BenchmarkDetail], None]]:
-        report_table = {
-            test_type.to_name(): result
-            for test_type, result in self.winning_behavior_test_results.get_test_pass_fail_report_by_type().items()
-            if test_type.to_name()
-        }
+        report_table: dict[str, dict[str, int]] = {}
+        for test_type, result in self.winning_behavior_test_results.get_test_pass_fail_report_by_type().items():
+            name = test_type.to_name()
+            if name:
+                report_table[name] = result
 
         result: dict[str, Union[str, int, dict[str, dict[str, int]], list[BenchmarkDetail], None]] = {
             "optimization_explanation": self.optimization_explanation,

codeflash/languages/javascript/find_references.py

@@ -651,15 +651,18 @@ def _find_reexports(
 
         """
         references: list[Reference] = []
+        export_name = exported.export_name or exported.function_name
+
+        # Skip expensive parsing if export name not in source
+        if export_name not in source_code:
+            return references
+
         exports = analyzer.find_exports(source_code)
         lines = source_code.splitlines()
 
         for exp in exports:
             if not exp.is_reexport:
                 continue
-
-            # Check if this re-exports our function
-            export_name = exported.export_name or exported.function_name
             for name, alias in exp.exported_names:
                 if name == export_name:
                     # This is a re-export of our function

codeflash/models/models.py

@@ -15,6 +15,7 @@
 
 if TYPE_CHECKING:
     from collections.abc import Iterator
+
 import enum
 import re
 import sys
@@ -876,15 +877,14 @@ def number_of_loops(self) -> int:
         return max(test_result.loop_index for test_result in self.test_results)
 
     def get_test_pass_fail_report_by_type(self) -> dict[TestType, dict[str, int]]:
-        report = {}
-        for test_type in TestType:
-            report[test_type] = {"passed": 0, "failed": 0}
+        report: dict[TestType, dict[str, int]] = {tt: {"passed": 0, "failed": 0} for tt in TestType}
         for test_result in self.test_results:
-            if test_result.loop_index == 1:
-                if test_result.did_pass:
-                    report[test_result.test_type]["passed"] += 1
-                else:
-                    report[test_result.test_type]["failed"] += 1
+            if test_result.loop_index != 1:
+                continue
+            if test_result.did_pass:
+                report[test_result.test_type]["passed"] += 1
+            else:
+                report[test_result.test_type]["failed"] += 1
         return report
 
     @staticmethod

codeflash/models/test_type.py

@@ -12,11 +12,13 @@ class TestType(Enum):
     def to_name(self) -> str:
         if self is TestType.INIT_STATE_TEST:
             return ""
-        names = {
-            TestType.EXISTING_UNIT_TEST: "⚙️ Existing Unit Tests",
-            TestType.INSPIRED_REGRESSION: "🎨 Inspired Regression Tests",
-            TestType.GENERATED_REGRESSION: "🌀 Generated Regression Tests",
-            TestType.REPLAY_TEST: "⏪ Replay Tests",
-            TestType.CONCOLIC_COVERAGE_TEST: "🔎 Concolic Coverage Tests",
-        }
-        return names[self]
+        return _TO_NAME_MAP[self]
+
+
+_TO_NAME_MAP: dict[TestType, str] = {
+    TestType.EXISTING_UNIT_TEST: "⚙️ Existing Unit Tests",
+    TestType.INSPIRED_REGRESSION: "🎨 Inspired Regression Tests",
+    TestType.GENERATED_REGRESSION: "🌀 Generated Regression Tests",
+    TestType.REPLAY_TEST: "⏪ Replay Tests",
+    TestType.CONCOLIC_COVERAGE_TEST: "🔎 Concolic Coverage Tests",
+}

codeflash/optimization/function_optimizer.py

@@ -496,6 +496,16 @@ def can_be_optimized(self) -> Result[tuple[bool, CodeOptimizationContext, dict[P
         should_run_experiment = self.experiment_id is not None
         logger.info(f"!lsp|Function Trace ID: {self.function_trace_id}")
         ph("cli-optimize-function-start", {"function_trace_id": self.function_trace_id})
+
+        # Early check: if --no-gen-tests is set, verify there are existing tests for this function
+        if self.args.no_gen_tests:
+            func_qualname = self.function_to_optimize.qualified_name_with_modules_from_root(self.project_root)
+            if not self.function_to_tests.get(func_qualname):
+                return Failure(
+                    f"No existing tests found for '{self.function_to_optimize.function_name}'. "
+                    f"Cannot optimize without tests when --no-gen-tests is set."
+                )
+
         self.cleanup_leftover_test_return_values()
         file_name_from_test_module_name.cache_clear()
         ctx_result = self.get_code_optimization_context()

pyproject.toml

@@ -272,6 +272,7 @@ ignore = [
     "ANN401",  # typing.Any disallowed
     "ARG001",  # Unused function argument (common in abstract/interface methods)
     "TRY300",  # Consider moving to else block
+    "FURB110", # if-exp-instead-of-or-operator - we prefer explicit if-else over "or"
     "TRY401",  # Redundant exception in logging.exception
     "PLR0911", # Too many return statements
     "PLW0603", # Global statement