Add Rust procedural bug generation modifiers

swesmith/bug_gen/adapters/rust.py

@@ -2,13 +2,95 @@
 import tree_sitter_rust as tsrs
 import warnings
 
-from swesmith.constants import TODO_REWRITE, CodeEntity
+from swesmith.constants import TODO_REWRITE, CodeEntity, CodeProperty
 from tree_sitter import Language, Parser, Query, QueryCursor
 
 RUST_LANGUAGE = Language(tsrs.language())
 
 
 class RustEntity(CodeEntity):
+    def _analyze_properties(self):
+        """Analyze Rust code properties."""
+        node = self.node
+
+        if node.type == "function_item":
+            self._tags.add(CodeProperty.IS_FUNCTION)
+
+        self._walk_for_properties(node)
+
+    def _walk_for_properties(self, n):
+        """Walk the AST and analyze properties."""
+        self._check_control_flow(n)
+        self._check_operations(n)
+        self._check_expressions(n)
+
+        for child in n.children:
+            self._walk_for_properties(child)
+
+    def _check_control_flow(self, n):
+        """Check for control flow patterns."""
+        if n.type in ["for_expression", "while_expression", "loop_expression"]:
+            self._tags.add(CodeProperty.HAS_LOOP)
+        if n.type == "if_expression":
+            self._tags.add(CodeProperty.HAS_IF)
+            for child in n.children:
+                if child.type == "else_clause":
+                    self._tags.add(CodeProperty.HAS_IF_ELSE)
+                    break
+        if n.type == "match_expression":
+            self._tags.add(CodeProperty.HAS_SWITCH)
+
+    def _check_operations(self, n):
+        """Check for various operations."""
+        if n.type == "index_expression":
+            self._tags.add(CodeProperty.HAS_LIST_INDEXING)
+        if n.type == "call_expression":
+            self._tags.add(CodeProperty.HAS_FUNCTION_CALL)
+        if n.type == "return_expression":
+            self._tags.add(CodeProperty.HAS_RETURN)
+        if n.type in ["let_declaration", "const_item", "static_item"]:
+            self._tags.add(CodeProperty.HAS_ASSIGNMENT)
+
+    def _check_expressions(self, n):
+        """Check for expression patterns."""
+        if n.type == "binary_expression":
+            self._tags.add(CodeProperty.HAS_BINARY_OP)
+        if n.type == "unary_expression":
+            self._tags.add(CodeProperty.HAS_UNARY_OP)
+        if n.type == "closure_expression":
+            self._tags.add(CodeProperty.HAS_LAMBDA)
+
+    @property
+    def complexity(self) -> int:
+        """Calculate cyclomatic complexity for Rust code."""
+
+        def walk(node):
+            score = 0
+            if node.type in [
+                "!=",
+                "&&",
+                "<",
+                "<=",
+                "==",
+                ">",
+                ">=",
+                "||",
+                "match_arm",
+                "else_clause",
+                "for_expression",
+                "while_expression",
+                "loop_expression",
+                "if_expression",
+            ]:
+                score += 1
+
+            for child in node.children:
+                score += walk(child)
+
+            return score
+
+        return 1 + walk(self.node)
+
     @property
     def name(self) -> str:
         func_query = Query(RUST_LANGUAGE, "(function_item name: (identifier) @name)")

swesmith/bug_gen/procedural/__init__.py

@@ -9,8 +9,10 @@
 # For backward compatibility, expose Python-specific classes
 from swesmith.bug_gen.procedural.golang import MODIFIERS_GOLANG
 from swesmith.bug_gen.procedural.python import MODIFIERS_PYTHON
+from swesmith.bug_gen.procedural.rust import MODIFIERS_RUST
 
 MAP_EXT_TO_MODIFIERS = {
     ".go": MODIFIERS_GOLANG,
     ".py": MODIFIERS_PYTHON,
+    ".rs": MODIFIERS_RUST,
 }

swesmith/bug_gen/procedural/rust/__init__.py

@@ -0,0 +1,30 @@
+from swesmith.bug_gen.procedural.base import ProceduralModifier
+from swesmith.bug_gen.procedural.rust.control_flow import (
+    ControlIfElseInvertModifier,
+    ControlShuffleLinesModifier,
+)
+from swesmith.bug_gen.procedural.rust.operations import (
+    OperationBreakChainsModifier,
+    OperationChangeConstantsModifier,
+    OperationChangeModifier,
+    OperationFlipOperatorModifier,
+    OperationSwapOperandsModifier,
+)
+from swesmith.bug_gen.procedural.rust.remove import (
+    RemoveAssignModifier,
+    RemoveConditionalModifier,
+    RemoveLoopModifier,
+)
+
+MODIFIERS_RUST: list[ProceduralModifier] = [
+    ControlIfElseInvertModifier(likelihood=0.75),
+    ControlShuffleLinesModifier(likelihood=0.75),
+    RemoveAssignModifier(likelihood=0.25),
+    RemoveConditionalModifier(likelihood=0.25),
+    RemoveLoopModifier(likelihood=0.25),
+    OperationBreakChainsModifier(likelihood=0.4),
+    OperationChangeConstantsModifier(likelihood=0.4),
+    OperationChangeModifier(likelihood=0.4),
+    OperationFlipOperatorModifier(likelihood=0.4),
+    OperationSwapOperandsModifier(likelihood=0.4),
+]

swesmith/bug_gen/procedural/rust/base.py

@@ -0,0 +1,6 @@
+from abc import ABC
+from swesmith.bug_gen.procedural.base import ProceduralModifier
+
+
+class RustProceduralModifier(ProceduralModifier, ABC):
+    """Base class for Rust-specific procedural modifications."""

swesmith/bug_gen/procedural/rust/control_flow.py

@@ -0,0 +1,202 @@
+import tree_sitter_rust as tsrs
+
+from swesmith.bug_gen.procedural.base import CommonPMs
+from swesmith.bug_gen.procedural.rust.base import RustProceduralModifier
+from swesmith.constants import BugRewrite, CodeEntity
+from tree_sitter import Language, Parser
+
+RUST_LANGUAGE = Language(tsrs.language())
+
+
+class ControlIfElseInvertModifier(RustProceduralModifier):
+    explanation: str = CommonPMs.CONTROL_IF_ELSE_INVERT.explanation
+    name: str = CommonPMs.CONTROL_IF_ELSE_INVERT.name
+    conditions: list = CommonPMs.CONTROL_IF_ELSE_INVERT.conditions
+    min_complexity: int = 5
+
+    def modify(self, code_entity: CodeEntity) -> BugRewrite:
+        """Apply if-else inversion to the Rust code."""
+        if not self.flip():
+            return None
+
+        parser = Parser(RUST_LANGUAGE)
+        tree = parser.parse(bytes(code_entity.src_code, "utf8"))
+
+        changed = False
+
+        for _ in range(self.max_attempts):
+            modified_code = self._invert_if_else_statements(
+                code_entity.src_code, tree.root_node
+            )
+
+            if modified_code != code_entity.src_code:
+                changed = True
+                break
+
+        if not changed:
+            return None
+
+        return BugRewrite(
+            rewrite=modified_code,
+            explanation=self.explanation,
+            strategy=self.name,
+        )
+
+    def _invert_if_else_statements(self, source_code: str, node) -> str:
+        """Recursively find and invert if-else statements by swapping the bodies."""
+        modifications = []
+
+        def collect_if_statements(n):
+            if n.type == "if_expression":
+                if_condition = None
+                if_body = None
+                else_clause = None
+                else_body = None
+
+                for i, child in enumerate(n.children):
+                    if child.type == "if":
+                        continue
+                    elif if_condition is None and child.type in [
+                        "binary_expression",
+                        "identifier",
+                        "call_expression",
+                        "field_expression",
+                        "unary_expression",
+                    ]:
+                        if_condition = child
+                    elif child.type == "block" and if_body is None:
+                        if_body = child
+                    elif child.type == "else_clause":
+                        else_clause = child
+                        for else_child in child.children:
+                            if else_child.type == "block":
+                                else_body = else_child
+                                break
+                        break
+
+                if (
+                    if_condition
+                    and if_body
+                    and else_clause
+                    and else_body
+                    and self.flip()
+                ):
+                    modifications.append((n, if_condition, if_body, else_body))
+
+            for child in n.children:
+                collect_if_statements(child)
+
+        collect_if_statements(node)
+
+        if not modifications:
+            return source_code
+
+        modified_source = source_code
+        for if_node, condition, if_body, else_body in reversed(modifications):
+            if_start = if_node.start_byte
+            if_body_start = if_body.start_byte
+
+            prefix = source_code[if_start:if_body_start].strip()
+
+            if_body_text = source_code[if_body.start_byte : if_body.end_byte]
+            else_body_text = source_code[else_body.start_byte : else_body.end_byte]
+
+            new_if_else = f"{prefix} {else_body_text} else {if_body_text}"
+
+            start_byte = if_node.start_byte
+            end_byte = if_node.end_byte
+
+            modified_source = (
+                modified_source[:start_byte] + new_if_else + modified_source[end_byte:]
+            )
+
+        return modified_source
+
+
+class ControlShuffleLinesModifier(RustProceduralModifier):
+    explanation: str = CommonPMs.CONTROL_SHUFFLE_LINES.explanation
+    name: str = CommonPMs.CONTROL_SHUFFLE_LINES.name
+    conditions: list = CommonPMs.CONTROL_SHUFFLE_LINES.conditions
+    max_complexity: int = 10
+
+    def modify(self, code_entity: CodeEntity) -> BugRewrite:
+        """Apply line shuffling to the Rust function body."""
+        parser = Parser(RUST_LANGUAGE)
+        tree = parser.parse(bytes(code_entity.src_code, "utf8"))
+
+        modified_code = self._shuffle_function_statements(
+            code_entity.src_code, tree.root_node
+        )
+
+        if modified_code == code_entity.src_code:
+            return None
+
+        return BugRewrite(
+            rewrite=modified_code,
+            explanation=self.explanation,
+            strategy=self.name,
+        )
+
+    def _shuffle_function_statements(self, source_code: str, node) -> str:
+        """Recursively find function declarations and shuffle their statements."""
+        modifications = []
+
+        def collect_function_declarations(n):
+            if n.type == "function_item":
+                body_block = None
+                for child in n.children:
+                    if child.type == "block":
+                        body_block = child
+                        break
+
+                if body_block:
+                    statements = []
+                    for child in body_block.children:
+                        if child.type not in ["{", "}"]:
+                            statements.append(child)
+
+                    if len(statements) >= 2:
+                        modifications.append((body_block, statements))
+
+            for child in n.children:
+                collect_function_declarations(child)
+
+        collect_function_declarations(node)
+
+        if not modifications:
+            return source_code
+
+        modified_source = source_code
+        for body_block, statements in reversed(modifications):
+            shuffled_indices = list(range(len(statements)))
+            self.rand.shuffle(shuffled_indices)
+
+            if shuffled_indices == list(range(len(statements))):
+                if len(statements) >= 2:
+                    shuffled_indices[0], shuffled_indices[1] = (
+                        shuffled_indices[1],
+                        shuffled_indices[0],
+                    )
+
+            statement_texts = []
+            for stmt in statements:
+                stmt_text = source_code[stmt.start_byte : stmt.end_byte]
+                statement_texts.append(stmt_text)
+
+            shuffled_texts = [statement_texts[i] for i in shuffled_indices]
+
+            first_stmt_start = statements[0].start_byte
+            last_stmt_end = statements[-1].end_byte
+
+            line_start = source_code.rfind("\n", 0, first_stmt_start) + 1
+            indent = source_code[line_start:first_stmt_start]
+
+            new_content = ("\n" + indent).join(shuffled_texts)
+
+            modified_source = (
+                modified_source[:first_stmt_start]
+                + new_content
+                + modified_source[last_stmt_end:]
+            )
+
+        return modified_source