shrinkray 0.0.0__py3-none-any.whl → 25.12.26.0__py3-none-any.whl

shrinkray/passes/python.py

@@ -1,4 +1,5 @@
-from typing import Any, AnyStr, Callable
+from collections.abc import Callable
+from typing import Any, cast
 
 import libcst
 import libcst.matchers as m
@@ -8,7 +9,7 @@ from shrinkray.problem import ReductionProblem
 from shrinkray.work import NotFound
 
 
-def is_python(source: AnyStr) -> bool:
+def is_python[AnyStr: (str, bytes)](source: AnyStr) -> bool:
     try:
         libcst.parse_module(source)
         return True
@@ -27,10 +28,20 @@ async def libcst_transform(
         Replacement,
     ],
 ) -> None:
+    """Apply a LibCST transformation to matching nodes in Python source.
+
+    Parses the test case as Python, finds all nodes matching the given
+    matcher, and applies the transformer function to each. Uses binary
+    search to efficiently find which transformations maintain interestingness.
+    """
+
     class CM(codemod.VisitorBasedCodemodCommand):
-        def __init__(self, context: codemod.CodemodContext, target_index: int):
+        def __init__(
+            self, context: codemod.CodemodContext, start_index: int, end_index: int
+        ):
             super().__init__(context)
-            self.target_index = target_index
+            self.start_index = start_index
+            self.end_index = end_index
             self.current_index = 0
             self.fired = False
 
@@ -39,8 +50,9 @@ async def libcst_transform(
         # and we use this generically in a way that makes it hard to type correctly.
         @m.leave(matcher)
         def maybe_change_node(self, _, updated_node):  # type: ignore
-            if self.current_index == self.target_index:
+            if self.start_index <= self.current_index < self.end_index:
                 self.fired = True
+                self.current_index += 1
                 return transformer(updated_node)
             else:
                 self.current_index += 1
@@ -53,14 +65,14 @@ async def libcst_transform(
 
     context = codemod.CodemodContext()
 
-    counting_mod = CM(context, -1)
+    counting_mod = CM(context, -1, -1)
     counting_mod.transform_module(module)
 
     n = counting_mod.current_index + 1
 
-    async def can_apply(i: int) -> bool:
+    async def can_apply(start: int, end: int) -> bool:
         nonlocal n
-        if i >= n:
+        if start >= n:
             return False
         initial_test_case = problem.current_test_case
         try:
@@ -69,7 +81,7 @@ async def libcst_transform(
             n = 0
             return False
 
-        codemod_i = CM(context, i)
+        codemod_i = CM(context, start, end)
         try:
             transformed = codemod_i.transform_module(module)
         except libcst.CSTValidationError:
@@ -80,7 +92,7 @@ async def libcst_transform(
             raise
 
         if not codemod_i.fired:
-            n = i
+            n = start
             return False
 
         transformed_test_case = transformed.code.encode(transformed.encoding)
@@ -95,12 +107,22 @@ async def libcst_transform(
     i = 0
     while i < n:
         try:
-            i = await problem.work.find_first_value(range(i, n), can_apply)
+            i = await problem.work.find_first_value(
+                range(i, n), lambda i: can_apply(i, i + 1)
+            )
+            await problem.work.find_large_integer(lambda k: can_apply(i + 1, i + 1 + k))
+            i += 1
         except NotFound:
             break
 
 
 async def lift_indented_constructs(problem: ReductionProblem[bytes]) -> None:
+    """Replace control structures with their body contents.
+
+    For if/while/try/with statements, removes the else/except clauses and
+    then tries to replace the entire construct with just its body. This
+    "lifts" the indented code out of its containing structure.
+    """
     await libcst_transform(
         problem,
         m.OneOf(m.While(), m.If(), m.Try()),
@@ -115,6 +137,11 @@ async def lift_indented_constructs(problem: ReductionProblem[bytes]) -> None:
 
 
 async def delete_statements(problem: ReductionProblem[bytes]) -> None:
+    """Try to delete simple statement lines from Python source.
+
+    Removes individual statements (assignments, expressions, imports, etc.)
+    one at a time to find which can be eliminated.
+    """
     await libcst_transform(
         problem,
         m.SimpleStatementLine(),
@@ -123,6 +150,11 @@ async def delete_statements(problem: ReductionProblem[bytes]) -> None:
 
 
 async def replace_statements_with_pass(problem: ReductionProblem[bytes]) -> None:
+    """Replace statement lines with 'pass' statements.
+
+    Useful when a statement can't be deleted outright (e.g., it's the only
+    statement in a block) but can be replaced with a no-op.
+    """
     await libcst_transform(
         problem,
         m.SimpleStatementLine(),
@@ -134,6 +166,11 @@ ELLIPSIS_STATEMENT = libcst.parse_statement("...")
 
 
 async def replace_bodies_with_ellipsis(problem: ReductionProblem[bytes]) -> None:
+    """Replace indented block bodies with '...' (ellipsis).
+
+    Replaces function bodies, class bodies, and other indented blocks
+    with just an ellipsis statement. Useful for stubbing out implementations.
+    """
     await libcst_transform(
         problem,
         m.IndentedBlock(),
@@ -142,6 +179,12 @@ async def replace_bodies_with_ellipsis(problem: ReductionProblem[bytes]) -> None
 
 
 async def strip_annotations(problem: ReductionProblem[bytes]) -> None:
+    """Remove type annotations from Python source.
+
+    Strips return type annotations from functions, parameter annotations,
+    and converts annotated assignments to plain assignments. Type annotations
+    are often unnecessary for reproducing bugs.
+    """
     await libcst_transform(
         problem,
         m.FunctionDef(),
@@ -152,19 +195,19 @@ async def strip_annotations(problem: ReductionProblem[bytes]) -> None:
         m.Param(),
         lambda x: x.with_changes(annotation=None),
     )
-    await libcst_transform(
-        problem,
-        m.AnnAssign(),
-        lambda x: (
-            libcst.Assign(
-                targets=[libcst.AssignTarget(target=x.target)],
-                value=x.value,
-                semicolon=x.semicolon,
+
+    def ann_assign_to_assign(x: libcst.CSTNode) -> Replacement:
+        ann = cast(libcst.AnnAssign, x)
+        if ann.value is not None:
+            return libcst.Assign(
+                targets=[libcst.AssignTarget(target=ann.target)],
+                value=ann.value,
+                semicolon=ann.semicolon,
             )
-            if x.value
-            else libcst.RemoveFromParent()
-        ),
-    )
+        else:
+            return libcst.RemoveFromParent()
+
+    await libcst_transform(problem, m.AnnAssign(), ann_assign_to_assign)
 
 
 PYTHON_PASSES = [