handle qualified names

Author: KRRT7

codeflash/discovery/discover_unit_tests.py

@@ -148,6 +148,7 @@ def __init__(self, function_names_to_find: set[str]) -> None:
         self.imported_names: set[str] = set()
         self.imported_modules: set[str] = set()
         self.found_target_functions: set[str] = set()
+        self.qualified_names_called: set[str] = set()
 
     def visit_Import(self, node: ast.Import) -> None:
         """Handle 'import module' statements."""
@@ -164,13 +165,16 @@ def visit_ImportFrom(self, node: ast.ImportFrom) -> None:
 
         for alias in node.names:
             if alias.name == "*":
-                # Star imports - we can't know what's imported, so be conservative
-                self.imported_names.add("*")
-            else:
-                imported_name = alias.asname if alias.asname else alias.name
-                self.imported_names.add(imported_name)
-                if alias.name in self.function_names_to_find:
-                    self.found_target_functions.add(alias.name)
+                continue
+            imported_name = alias.asname if alias.asname else alias.name
+            self.imported_names.add(imported_name)
+            if alias.name in self.function_names_to_find:
+                self.found_target_functions.add(alias.name)
+            # Check for qualified name matches
+            if node.module:
+                qualified_name = f"{node.module}.{alias.name}"
+                if qualified_name in self.function_names_to_find:
+                    self.found_target_functions.add(qualified_name)
         self.generic_visit(node)
 
     def visit_Call(self, node: ast.Call) -> None:
@@ -207,6 +211,9 @@ def visit_Attribute(self, node: ast.Attribute) -> None:
         """Handle module.function_name patterns."""
         if node.attr in self.function_names_to_find:
             self.found_target_functions.add(node.attr)
+            if isinstance(node.value, ast.Name):
+                qualified_name = f"{node.value.id}.{node.attr}"
+                self.qualified_names_called.add(qualified_name)
         self.generic_visit(node)
 
 
@@ -232,37 +239,10 @@ def analyze_imports_in_test_file(test_file_path: Path | str, target_functions: s
         analyzer = ImportAnalyzer(target_functions)
         analyzer.visit(tree)
 
-        # If we found direct function matches, definitely process
         if analyzer.found_target_functions:
             return True, analyzer.found_target_functions
 
-        # If there are star imports, we need to be conservative
-        if "*" in analyzer.imported_names:
-            return True, set()
-
-        # Check for direct name matches first (higher priority)
-        name_matches = analyzer.imported_names & target_functions
-        if name_matches:
-            return True, name_matches
-
-        # If no direct matches, check if any imported modules could contain our target functions
-        # This is a heuristic - we look for common patterns
-        potential_matches = set()
-        for module in analyzer.imported_modules:
-            # Check if module name suggests it could contain target functions
-            for func_name in target_functions:
-                # Only match if the module name is a prefix of the function qualified name
-                func_parts = func_name.split(".")
-                if len(func_parts) > 1 and module == func_parts[0]:
-                    # Module matches the first part of qualified name (e.g., mycode in mycode.target_function)
-                    # But only if we don't have specific import information suggesting otherwise
-                    potential_matches.add(func_name)
-                elif any(part in module for part in func_name.split("_")) and len(func_name.split("_")) > 1:
-                    # Function name parts match module name (for underscore-separated names)
-                    potential_matches.add(func_name)
-
-        # Only use heuristic matches if we haven't found specific function imports that contradict them
-        return bool(potential_matches), potential_matches
+        return False, set()  # noqa: TRY300
 
     except (SyntaxError, UnicodeDecodeError, OSError) as e:
         logger.debug(f"Failed to analyze imports in {test_file_path}: {e}")
@@ -283,7 +263,6 @@ def filter_test_files_by_imports(
 
     """
     if not target_functions:
-        # If no target functions specified, process all files
         return file_to_test_map, {}
 
     filtered_map = {}
@@ -479,7 +458,7 @@ def process_test_files(
         target_function_names = set()
         for func in functions_to_optimize:
             target_function_names.add(func.qualified_name)
-        logger.debug(f"Target functions for import filtering: {target_function_names}")
+        logger.info(f"Target functions for import filtering: {target_function_names}")
         file_to_test_map, import_results = filter_test_files_by_imports(file_to_test_map, target_function_names)
         logger.debug(f"Import analysis results: {len(import_results)} files analyzed")
 

tests/test_unit_test_discovery.py

@@ -9,6 +9,7 @@
 )
 from codeflash.models.models import TestsInFile, TestType
 from codeflash.verification.verification_utils import TestConfig
+from codeflash.discovery.functions_to_optimize import FunctionToOptimize
 
 
 def test_unit_test_discovery_pytest():
@@ -832,8 +833,8 @@ def test_something():
         target_functions = {"target_function"}
         should_process, found_functions = analyze_imports_in_test_file(test_file, target_functions)
 
-        assert should_process is True  # Conservative approach with star imports
-        assert found_functions == set()  # No specific functions identified
+        assert should_process is False
+        assert found_functions == set()
 
 
 def test_analyze_imports_module_import():
@@ -907,13 +908,11 @@ def test_unrelated():
 
         target_functions = {"target_function", "another_function"}
         should_process, found_functions = analyze_imports_in_test_file(test_file, target_functions)
-        
         assert should_process is False
         assert found_functions == set()
 
 
-def test_analyze_imports_heuristic_matching():
-    """Test heuristic module name matching."""
+def test_analyze_qualified_names():
     with tempfile.TemporaryDirectory() as tmpdirname:
         test_file = Path(tmpdirname) / "test_example.py"
         test_content = """
@@ -924,11 +923,11 @@ def test_target():
 """
         test_file.write_text(test_content)
 
-        target_functions = {"target_function"}  # Function name partially matches module name
+        target_functions = {"target_module.some_function"}
         should_process, found_functions = analyze_imports_in_test_file(test_file, target_functions)
-        
         assert should_process is True
-        assert "target_function" in found_functions
+        assert "target_module.some_function" in found_functions
+
 
 
 def test_analyze_imports_syntax_error():
@@ -952,7 +951,6 @@ def test_target(
 
 
 def test_filter_test_files_by_imports():
-    """Test the complete filtering functionality."""
     with tempfile.TemporaryDirectory() as tmpdirname:
         tmpdir = Path(tmpdirname)
 
@@ -974,7 +972,7 @@ def test_other():
     assert other_function() is True
 """)
 
-        # Create test file with star import (should be processed)
+        # Create test file with star import (should not be processed)
         star_test = tmpdir / "test_star.py"
         star_test.write_text("""
 from mymodule import *
@@ -983,7 +981,6 @@ def test_star():
     assert something() is True
 """)
 
-        # Build file_to_test_map
         file_to_test_map = {
             relevant_test: [TestsInFile(test_file=relevant_test, test_function="test_target", test_class=None, test_type=TestType.EXISTING_UNIT_TEST)],
             irrelevant_test: [TestsInFile(test_file=irrelevant_test, test_function="test_other", test_class=None, test_type=TestType.EXISTING_UNIT_TEST)],
@@ -993,16 +990,15 @@ def test_star():
         target_functions = {"target_function"}
         filtered_map, import_results = filter_test_files_by_imports(file_to_test_map, target_functions)
 
-        # Should filter out irrelevant_test but keep relevant_test and star_test
-        assert len(filtered_map) == 2
+        # Should filter out irrelevant_test
+        assert len(filtered_map) == 1
         assert relevant_test in filtered_map
-        assert star_test in filtered_map
         assert irrelevant_test not in filtered_map
 
         # Check import analysis results
         assert "target_function" in import_results[relevant_test]
         assert len(import_results[irrelevant_test]) == 0
-        assert len(import_results[star_test]) == 0  # Star import doesn't identify specific functions
+        assert len(import_results[star_test]) == 0
 
 
 def test_filter_test_files_no_target_functions():
@@ -1066,18 +1062,17 @@ def test_other():
             tests_project_rootdir=tmpdir.parent,
         )
 
-        # Test without filtering
         all_tests, _ = discover_unit_tests(test_config)
-        assert len(all_tests) == 2  # Should find both functions
-        
-        # Test with filtering - create mock FunctionToOptimize objects
-        from unittest.mock import Mock
-        mock_function = Mock()
-        mock_function.qualified_name_with_modules_from_root.return_value = "mycode.target_function"
-        mock_function.function_name = "target_function"
-        mock_function.parents = []  # No parent classes
+        assert len(all_tests) == 2 
 
-        filtered_tests, _ = discover_unit_tests(test_config, file_to_funcs_to_optimize={code_file: [mock_function]})
+
+        fto = FunctionToOptimize(
+            function_name="target_function",
+            file_path=code_file,
+            parents=[],
+        )
+
+        filtered_tests, _ = discover_unit_tests(test_config, file_to_funcs_to_optimize={code_file: [fto]})
         assert len(filtered_tests) >= 1
         assert "mycode.target_function" in filtered_tests
 
@@ -1146,7 +1141,6 @@ def test_aliased():
 
 
 def test_analyze_imports_underscore_function_names():
-    """Test handling of function names with underscores in heuristic matching."""
     with tempfile.TemporaryDirectory() as tmpdirname:
         test_file = Path(tmpdirname) / "test_example.py"
         test_content = """
@@ -1157,12 +1151,11 @@ def test_bubble():
 """
         test_file.write_text(test_content)
 
-        target_functions = {"bubble_sort"}  # Function name parts match module
+        target_functions = {"bubble_sort"}
         should_process, found_functions = analyze_imports_in_test_file(test_file, target_functions)
 
-        assert should_process is True
-        assert "bubble_sort" in found_functions
-
+        assert should_process is False
+        assert "bubble_sort" not in found_functions
 
 def test_discover_unit_tests_filtering_different_modules():
     """Test import filtering with test files from completely different modules."""