feat: add test coverage exclusion for Yul preprocessor (#1037)

# Rationale for this change
Currently we do not do test coverage exclusion for the Yul preprocessor
hence code coverage fails. Now we are fixing this.

Author: iajoiner

solidity/preprocessor/test_yul_preprocessor.py

@@ -237,6 +237,11 @@ def test_self_import(self):
         # Verify it's usable in the second block
         assert "let value := utilFunc(10)" in result
 
+        # IMPORTANT: When importing from self (different assembly block in same file),
+        # the imported function SHOULD have coverage exclusion markers
+        assert "function exclude_coverage_start_utilFunc() {}" in result
+        assert "function exclude_coverage_stop_utilFunc() {}" in result
+
     def test_self_import_multiple(self):
         """Test importing multiple functions from a different assembly block in the same file."""
         test_dir = self.test_files_dir / "self_import"
@@ -254,6 +259,13 @@ def test_self_import_multiple(self):
         assert "let doubled := helper(5)" in result
         assert "let increased := anotherHelper(doubled)" in result
 
+        # IMPORTANT: When importing from self (different assembly block in same file),
+        # the imported functions SHOULD have coverage exclusion markers
+        assert "function exclude_coverage_start_helper() {}" in result
+        assert "function exclude_coverage_stop_helper() {}" in result
+        assert "function exclude_coverage_start_anotherHelper() {}" in result
+        assert "function exclude_coverage_stop_anotherHelper() {}" in result
+
     def test_circular_with_external_import(self):
         """Test that C can import from a circular group A-B."""
         test_dir = self.test_files_dir / "circular_regular"
@@ -602,17 +614,90 @@ def test_slither_comments_preserved(self):
         # Should have slither-disable-next-line before simpleFunction
         assert "// slither-disable-next-line write-after-write" in result
 
+        # Verify coverage exclusion markers are added
+        assert "function exclude_coverage_start_complexFunction() {}" in result
+        assert "function exclude_coverage_stop_complexFunction() {}" in result
+        assert "function exclude_coverage_start_simpleFunction() {}" in result
+        assert "function exclude_coverage_stop_simpleFunction() {}" in result
+
         # Verify the ordering is correct (disable-start comes before the function)
         start_idx = result.find("// slither-disable-start cyclomatic-complexity")
+        cov_start_idx = result.find("function exclude_coverage_start_complexFunction")
         func_idx = result.find("function complexFunction")
+        cov_stop_idx = result.find("function exclude_coverage_stop_complexFunction")
         end_idx = result.find("// slither-disable-end cyclomatic-complexity")
         assert (
-            start_idx < func_idx < end_idx
-        ), "Slither comments should wrap the function"
+            start_idx < cov_start_idx < func_idx < cov_stop_idx < end_idx
+        ), "Slither comments and coverage markers should properly wrap the function"
 
         # Verify no duplicate disable-end comments
         assert result.count("// slither-disable-end cyclomatic-complexity") == 1
 
+    def test_coverage_exclusion_for_external_imports(self):
+        """Test that functions imported from external files get coverage exclusion markers."""
+        test_dir = self.test_files_dir / "basic_import"
+        target_file = test_dir / "main.presl"
+
+        preprocessor = YulPreprocessor(root_dir=test_dir)
+        result = preprocessor.process_file(target_file)
+
+        # Verify the imported function has coverage exclusion markers
+        assert "function exclude_coverage_start_add5() {}" in result
+        assert "function exclude_coverage_stop_add5() {}" in result
+
+        # Verify the markers wrap the function
+        start_idx = result.find("function exclude_coverage_start_add5")
+        func_idx = result.find("function add5(x) -> result")
+        stop_idx = result.find("function exclude_coverage_stop_add5")
+        assert (
+            start_idx < func_idx < stop_idx
+        ), "Coverage markers should wrap the imported function"
+
+    def test_coverage_exclusion_circular_dependencies(self):
+        """Test that functions in their own file are NOT coverage-excluded in circular dependencies."""
+        test_dir = self.test_files_dir / "circular_regular"
+        file_a = test_dir / "a.presl"
+        file_b = test_dir / "b.presl"
+
+        preprocessor = YulPreprocessor(root_dir=test_dir)
+        result_a = preprocessor.process_file(file_a)
+        result_b = preprocessor.process_file(file_b)
+
+        # In a.post.sol, funcA is defined locally so it should NOT have coverage exclusion
+        # but funcB is imported so it SHOULD have coverage exclusion
+
+        # funcB imported into a.post.sol should have coverage exclusion
+        assert "function exclude_coverage_start_funcB() {}" in result_a
+        assert "function exclude_coverage_stop_funcB() {}" in result_a
+
+        # funcA imported into b.post.sol should have coverage exclusion
+        assert "function exclude_coverage_start_funcA() {}" in result_b
+        assert "function exclude_coverage_stop_funcA() {}" in result_b
+
+        # IMPORTANT: funcA in a.post.sol should NOT have coverage exclusion
+        # because it's defined in a.presl (the source file for a.post.sol)
+        assert "function exclude_coverage_start_funcA() {}" not in result_a
+        assert "function exclude_coverage_stop_funcA() {}" not in result_a
+
+        # Similarly, funcB in b.post.sol should NOT have coverage exclusion
+        # because it's defined in b.presl (the source file for b.post.sol)
+        assert "function exclude_coverage_start_funcB() {}" not in result_b
+        assert "function exclude_coverage_stop_funcB() {}" not in result_b
+
+    def test_coverage_exclusion_with_dependencies(self):
+        """Test that transitive dependencies also get coverage exclusion markers."""
+        test_dir = self.test_files_dir / "multiple_imports"
+        target_file = test_dir / "calculator.presl"
+
+        preprocessor = YulPreprocessor(root_dir=test_dir)
+        result = preprocessor.process_file(target_file)
+
+        # Both imported functions should have coverage exclusion markers
+        assert "function exclude_coverage_start_multiply() {}" in result
+        assert "function exclude_coverage_stop_multiply() {}" in result
+        assert "function exclude_coverage_start_divide() {}" in result
+        assert "function exclude_coverage_stop_divide() {}" in result
+
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

solidity/preprocessor/yul_preprocessor.py

@@ -40,6 +40,7 @@ def __init__(
         full_text: str,
         pre_comments: str = "",
         post_comments: str = "",
+        source_file: Optional[Path] = None,
     ):
         self.name = name
         self.signature = signature  # function name(...) -> ...
@@ -51,6 +52,7 @@ def __init__(
         self.post_comments = (
             post_comments  # Comments after function (e.g., slither-disable-end)
         )
+        self.source_file = source_file  # The .presl file where this function is defined
 
     def __eq__(self, other):
         if not isinstance(other, YulFunction):
@@ -120,7 +122,9 @@ def find_assembly_blocks(self, content: str) -> List[Tuple[int, int, str]]:
 
         return blocks
 
-    def extract_yul_functions(self, assembly_content: str) -> Dict[str, YulFunction]:
+    def extract_yul_functions(
+        self, assembly_content: str, source_file: Optional[Path] = None
+    ) -> Dict[str, YulFunction]:
         """
         Extract all Yul function definitions from an assembly block.
         Returns dict mapping function name to YulFunction object.
@@ -238,6 +242,7 @@ def extract_yul_functions(self, assembly_content: str) -> Dict[str, YulFunction]
                     full_text=full_text,
                     pre_comments=pre_comments,
                     post_comments=post_comments,
+                    source_file=source_file,
                 )
             else:
                 i += 1
@@ -390,7 +395,7 @@ def collect_all_functions_in_cycle(
             assembly_blocks = self.find_assembly_blocks(content)
 
             for _, _, block_content in assembly_blocks:
-                functions = self.extract_yul_functions(block_content)
+                functions = self.extract_yul_functions(block_content, file_path)
                 for func_name, func in functions.items():
                     if func_name in all_functions:
                         # Check for signature conflicts
@@ -425,6 +430,9 @@ def process_file(
         Returns the processed content.
         Handles circular dependencies by processing dependency cycles as unified groups.
         """
+        # Ensure file_path is resolved to an absolute path for consistent comparison
+        file_path = file_path.resolve()
+
         if processing_stack is None:
             processing_stack = []
 
@@ -523,7 +531,9 @@ def process_assembly_block(
             current_cycle_key = frozenset(cycle_group)
 
         # Extract local functions from this block to detect what needs to be deduplicated
-        local_functions = self.extract_yul_functions(block_content)
+        # These are functions defined in THIS specific assembly block
+        local_functions = self.extract_yul_functions(block_content, current_file)
+        local_function_names = set(local_functions.keys())
 
         i = 0
         while i < len(lines):
@@ -623,11 +633,27 @@ def process_assembly_block(
         if imported_functions:
             func_lines = []
             for func in imported_functions.values():
+                # A function should NOT have coverage exclusion if it's defined in THIS assembly block
+                # It SHOULD have coverage exclusion if it's imported from:
+                # 1. A different file (func.source_file != current_file)
+                # 2. The same file but a different assembly block (func.name not in local_function_names)
+                is_truly_local = func.name in local_function_names
+
                 # Include pre-comments (e.g., slither-disable-start)
                 if func.pre_comments:
                     func_lines.append(func.pre_comments)
+                # Add coverage exclusion start marker only for non-local functions
+                if not is_truly_local:
+                    func_lines.append(
+                        f"            function exclude_coverage_start_{func.name}() {{}} // solhint-disable-line no-empty-blocks"
+                    )
                 # Add the function itself
                 func_lines.append(func.full_text)
+                # Add coverage exclusion stop marker only for non-local functions
+                if not is_truly_local:
+                    func_lines.append(
+                        f"            function exclude_coverage_stop_{func.name}() {{}} // solhint-disable-line no-empty-blocks"
+                    )
                 # Include post-comments (e.g., slither-disable-end)
                 if func.post_comments:
                     func_lines.append(func.post_comments)
@@ -666,7 +692,7 @@ def resolve_import(
             external_deps = {}  # Track functions imported from external files
 
             for _, _, block_content in assembly_blocks:
-                functions = self.extract_yul_functions(block_content)
+                functions = self.extract_yul_functions(block_content, current_file)
                 all_functions.update(functions)
 
                 # Also resolve any imports within this block to get external dependencies
@@ -771,7 +797,7 @@ def resolve_import(
         # Extract all functions from all assembly blocks
         all_functions = {}
         for _, _, block_content in assembly_blocks:
-            functions = self.extract_yul_functions(block_content)
+            functions = self.extract_yul_functions(block_content, target_file)
             all_functions.update(functions)
 
         # Check if the requested function exists