feat: allow slither check disabling in Yul preprocessor (#1035)

# Rationale for this change
We need this feature in the Yul preprocessor since we have two legit Yul
functions with high cyclomatic complexity.

Author: iajoiner

solidity/preprocessor/test_files/slither_comments/main.presl

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+contract SlitherTestMain {
+    function testFunc() public pure {
+        assembly {
+            // import complexFunction from source.presl
+            // import simpleFunction from source.presl
+
+            let x := complexFunction(1, 2, 3)
+            let y := simpleFunction(5)
+        }
+    }
+}

solidity/preprocessor/test_files/slither_comments/source.presl

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.24;
+
+contract SlitherTestSource {
+    function testFunc() public pure {
+        assembly {
+            // slither-disable-start cyclomatic-complexity
+            function complexFunction(a, b, c) -> result {
+                result := add(a, add(b, c))
+            }
+            // slither-disable-end cyclomatic-complexity
+
+            // slither-disable-next-line write-after-write
+            function simpleFunction(x) -> y {
+                y := mul(x, 2)
+            }
+        }
+    }
+}

solidity/preprocessor/test_yul_preprocessor.py

@@ -582,6 +582,37 @@ def test_no_presl_references_in_post_sol_imports(self):
                 if output_file.exists():
                     output_file.unlink()
 
+    def test_slither_comments_preserved(self):
+        """Test that Slither exemption comments are preserved with imported functions."""
+        test_dir = self.test_files_dir / "slither_comments"
+        main_file = test_dir / "main.presl"
+
+        preprocessor = YulPreprocessor(root_dir=test_dir)
+        result = preprocessor.process_file(main_file)
+
+        # Verify both functions were imported
+        assert "function complexFunction(a, b, c) -> result" in result
+        assert "function simpleFunction(x) -> y" in result
+
+        # Verify Slither comments are preserved
+        # Should have slither-disable-start before complexFunction
+        assert "// slither-disable-start cyclomatic-complexity" in result
+        # Should have slither-disable-end after complexFunction
+        assert "// slither-disable-end cyclomatic-complexity" in result
+        # Should have slither-disable-next-line before simpleFunction
+        assert "// slither-disable-next-line write-after-write" in result
+
+        # Verify the ordering is correct (disable-start comes before the function)
+        start_idx = result.find("// slither-disable-start cyclomatic-complexity")
+        func_idx = result.find("function complexFunction")
+        end_idx = result.find("// slither-disable-end cyclomatic-complexity")
+        assert (
+            start_idx < func_idx < end_idx
+        ), "Slither comments should wrap the function"
+
+        # Verify no duplicate disable-end comments
+        assert result.count("// slither-disable-end cyclomatic-complexity") == 1
+
 
 if __name__ == "__main__":
     pytest.main([__file__, "-v"])

solidity/preprocessor/yul_preprocessor.py

@@ -32,11 +32,25 @@
 class YulFunction:
     """Represents a parsed Yul function."""
 
-    def __init__(self, name: str, signature: str, body: str, full_text: str):
+    def __init__(
+        self,
+        name: str,
+        signature: str,
+        body: str,
+        full_text: str,
+        pre_comments: str = "",
+        post_comments: str = "",
+    ):
         self.name = name
         self.signature = signature  # function name(...) -> ...
         self.body = body
         self.full_text = full_text  # Complete function including definition
+        self.pre_comments = (
+            pre_comments  # Comments before function (e.g., slither-disable-start)
+        )
+        self.post_comments = (
+            post_comments  # Comments after function (e.g., slither-disable-end)
+        )
 
     def __eq__(self, other):
         if not isinstance(other, YulFunction):
@@ -111,6 +125,7 @@ def extract_yul_functions(self, assembly_content: str) -> Dict[str, YulFunction]
         Extract all Yul function definitions from an assembly block.
         Returns dict mapping function name to YulFunction object.
         Handles multiline function signatures.
+        Captures Slither exemption comments before and after functions.
         """
         functions = {}
 
@@ -123,6 +138,29 @@ def extract_yul_functions(self, assembly_content: str) -> Dict[str, YulFunction]
 
             # Check if line starts with "function" keyword
             if line.strip().startswith("function"):
+                # Look back for Slither disable comments before the function
+                # Only capture slither-disable-start or slither-disable-next-line
+                # Do NOT capture slither-disable-end as that belongs to the previous function
+                pre_comment_lines = []
+                j = i - 1
+                while j >= 0:
+                    prev_line = lines[j].strip()
+                    # Check for slither-disable-start or slither-disable-next-line (not disable-end)
+                    if "slither-disable" in prev_line and prev_line.startswith("//"):
+                        if "slither-disable-end" not in prev_line:
+                            # This is a disable-start or disable-next-line, include it
+                            pre_comment_lines.insert(0, lines[j])
+                            j -= 1
+                        else:
+                            # This is a disable-end from a previous function, stop here
+                            break
+                    elif prev_line == "":
+                        # Allow empty lines but don't add them
+                        j -= 1
+                    else:
+                        # Stop when we hit non-comment/non-empty content
+                        break
+
                 # Extract function name using simple pattern
                 func_match = self.function_name_pattern.search(line)
 
@@ -167,11 +205,39 @@ def extract_yul_functions(self, assembly_content: str) -> Dict[str, YulFunction]
                     brace_count += lines[i].count("{") - lines[i].count("}")
                     i += 1
 
+                # Look ahead for Slither disable-end comments after the function
+                post_comment_lines = []
+                temp_i = i
+                while temp_i < len(lines):
+                    next_line = lines[temp_i].strip()
+                    # Check for slither-disable-end
+                    if "slither-disable-end" in next_line and next_line.startswith(
+                        "//"
+                    ):
+                        post_comment_lines.append(lines[temp_i])
+                        i = temp_i + 1
+                        break
+                    elif next_line == "":
+                        # Allow empty lines
+                        temp_i += 1
+                    else:
+                        # Stop when we hit any other content (function or non-comment)
+                        break
+
                 full_text = "\n".join(func_lines)
                 body = "\n".join(func_lines[len(sig_lines) :])
+                pre_comments = "\n".join(pre_comment_lines) if pre_comment_lines else ""
+                post_comments = (
+                    "\n".join(post_comment_lines) if post_comment_lines else ""
+                )
 
                 functions[func_name] = YulFunction(
-                    name=func_name, signature=signature, body=body, full_text=full_text
+                    name=func_name,
+                    signature=signature,
+                    body=body,
+                    full_text=full_text,
+                    pre_comments=pre_comments,
+                    post_comments=post_comments,
                 )
             else:
                 i += 1
@@ -557,7 +623,14 @@ def process_assembly_block(
         if imported_functions:
             func_lines = []
             for func in imported_functions.values():
+                # Include pre-comments (e.g., slither-disable-start)
+                if func.pre_comments:
+                    func_lines.append(func.pre_comments)
+                # Add the function itself
                 func_lines.append(func.full_text)
+                # Include post-comments (e.g., slither-disable-end)
+                if func.post_comments:
+                    func_lines.append(func.post_comments)
 
             # Add imported functions before other content
             return "\n".join(func_lines) + "\n" + "\n".join(result_lines)