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

shrinkray/passes/clangdelta.py

@@ -1,5 +1,6 @@
 import os
 import subprocess
+from functools import lru_cache
 from glob import glob
 from shutil import which
 from tempfile import NamedTemporaryFile
@@ -10,6 +11,7 @@ from shrinkray.passes.definitions import ReductionPump
 from shrinkray.problem import ReductionProblem
 from shrinkray.work import NotFound
 
+
 C_FILE_EXTENSIONS = (".c", ".cpp", ".h", ".hpp", ".cxx", ".cc")
 
 
@@ -24,6 +26,29 @@ def find_clang_delta():
     return clang_delta
 
 
+@lru_cache(maxsize=1)
+def clang_delta_works() -> bool:
+    """Check if clang_delta can actually execute.
+
+    This verifies not just that the binary exists, but that it can run.
+    On some systems (e.g., Ubuntu 24.04), creduce is installed but
+    clang_delta fails at runtime due to shared library issues.
+    """
+    clang_delta = find_clang_delta()
+    if not clang_delta:
+        return False
+    try:
+        # Run a simple test to verify clang_delta works
+        result = subprocess.run(
+            [clang_delta, "--help"],
+            capture_output=True,
+            timeout=5,
+        )
+        return result.returncode == 0
+    except (OSError, subprocess.TimeoutExpired):
+        return False
+
+
 TRANSFORMATIONS: list[str] = [
     "aggregate-to-scalar",
     "binop-simplification",
@@ -126,9 +151,10 @@ class ClangDelta:
                 ).stdout
             except subprocess.CalledProcessError as e:
                 msg = (e.stdout + e.stderr).strip()
-                if msg == b"Error: Unsupported file type!":
-                    raise ValueError("Not a C or C++ test case")
-                elif b"Assertion failed" in msg:
+                # clang_delta has many internal assertions that can be triggered
+                # by malformed or unusual C/C++ code. These are harmless - we just
+                # report zero instances and skip this transformation.
+                if b"Assertion failed" in msg:
                     return 0
                 else:
                     raise ClangDeltaError(msg)
@@ -161,13 +187,13 @@ class ClangDelta:
                     )
                 ).stdout
             except subprocess.CalledProcessError as e:
-                if e.stdout.strip() == b"Error: Unsupported file type!":
-                    raise ValueError("Not a C or C++ test case")
-                elif (
+                if (
                     e.stdout.strip()
                     == b"Error: No modification to the transformed program!"
                 ):
                     return data
+                elif b"Assertion failed" in e.stderr.strip():
+                    return data
                 else:
                     raise ClangDeltaError(e.stdout + e.stderr)
             finally:
@@ -175,7 +201,9 @@ class ClangDelta:
 
 
 class ClangDeltaError(Exception):
-    pass
+    def __init__(self, message):
+        assert b"Assertion failed" not in message, message
+        super().__init__(message)
 
 
 def clang_delta_pump(
@@ -186,10 +214,7 @@ def clang_delta_pump(
         assert target is not None
         try:
             n = await clang_delta.query_instances(transformation, target)
-        except ValueError:
-            import traceback
-
-            traceback.print_exc()
+        except ClangDeltaError:
             return target
         i = 1
         while i <= n:
@@ -203,15 +228,20 @@ def clang_delta_pump(
                     return False
                 return await problem.is_interesting(attempt)
 
+            not_found = False
+            clang_delta_failed = False
             try:
                 i = await problem.work.find_first_value(range(i, n + 1), can_apply)
-            except NotFound:
+            except* NotFound:
+                not_found = True
+            except* ClangDeltaError:
+                # clang_delta assertions can be triggered by unusual C/C++ code.
+                # These are harmless - just return what we have so far.
+                clang_delta_failed = True
+            if not_found:
                 break
-            except ClangDeltaError as e:
-                # Clang delta has a large number of internal assertions that you can trigger
-                # if you feed it bad enough C++. We solve this problem by ignoring it.
-                if b"Assertion failed" in e.args[0]:
-                    return target
+            if clang_delta_failed:
+                return target
 
             target = await clang_delta.apply_transformation(transformation, i, target)
             assert target is not None

shrinkray/passes/definitions.py

@@ -1,30 +1,93 @@
+"""Type definitions and utilities for reduction passes.
+
+This module defines the core type aliases and abstractions for reduction:
+
+- ReductionPass[T]: A function that attempts to reduce a test case
+- ReductionPump[T]: A function that may temporarily increase test case size
+- Format[S, T]: A bidirectional transformation between types
+- compose(): Combines a Format with a pass to work on a different type
+
+These abstractions enable format-agnostic reduction: the same pass
+(e.g., "delete duplicate elements") can work on bytes, lines, tokens,
+JSON arrays, or any other sequence-like type.
+"""
+
 from abc import ABC, abstractmethod
+from collections.abc import Awaitable, Callable
 from functools import wraps
-from typing import Awaitable, Callable, Generic, TypeVar
+from typing import TypeVar
 
 from shrinkray.problem import ReductionProblem
 
+
 S = TypeVar("S")
 T = TypeVar("T")
 
 
+# A reduction pass takes a problem and attempts to reduce it.
+# The pass modifies the problem by calling is_interesting() with smaller candidates.
+# When a reduction succeeds, problem.current_test_case is automatically updated.
 ReductionPass = Callable[[ReductionProblem[T]], Awaitable[None]]
+
+# A reduction pump can temporarily INCREASE test case size.
+# Example: inlining a function makes code larger, but may enable further reductions.
+# The reducer runs passes on the pumped result using backtrack() to try to
+# reduce it below the original size.
 ReductionPump = Callable[[ReductionProblem[T]], Awaitable[T]]
 
 
 class ParseError(Exception):
+    """Raised when a Format cannot parse its input."""
+
+    pass
+
+
+class DumpError(Exception):
+    """Raised when a Format cannot serialize its output.
+
+    This occurs because not all internal representations map to valid
+    output in the target format. For example, a reduction might create
+    an invalid AST structure that cannot be converted back to source code.
+    """
+
     pass
 
 
-class Format(Generic[S, T], ABC):
+class Format[S, T](ABC):
+    """A bidirectional transformation between two types.
+
+    Formats enable format-agnostic passes by abstracting the
+    parse/serialize cycle. For example:
+
+    - Split(b"\\n"): bytes <-> list[bytes] (lines)
+    - Tokenize(): bytes <-> list[bytes] (tokens)
+    - JSON: bytes <-> Any (Python objects)
+    - DimacsCNF: bytes <-> list[list[int]] (SAT clauses)
+
+    A Format must satisfy the round-trip property:
+        dumps(parse(x)) should be equivalent to x
+        (possibly with normalization)
+
+    Example usage:
+        # Delete duplicate lines
+        compose(Split(b"\\n"), delete_duplicates)
+
+        # Reduce integer literals in source code
+        compose(IntegerFormat(), reduce_integer)
+    """
+
     @property
     def name(self) -> str:
+        """Human-readable name for this format, used in pass names."""
         return repr(self)
 
     @abstractmethod
-    def parse(self, input: S) -> T: ...
+    def parse(self, input: S) -> T:
+        """Parse input into the target type. Raises ParseError on failure."""
+        ...
 
     def is_valid(self, input: S) -> bool:
+        """Check if input can be parsed by this format."""
         try:
             self.parse(input)
             return True
@@ -32,10 +95,27 @@ class Format(Generic[S, T], ABC):
             return False
 
     @abstractmethod
-    def dumps(self, input: T) -> S: ...
+    def dumps(self, input: T) -> S:
+        """Serialize the target type back to the source type."""
+        ...
 
 
 def compose(format: Format[S, T], reduction_pass: ReductionPass[T]) -> ReductionPass[S]:
+    """Wrap a reduction pass to work through a Format transformation.
+
+    This is the key combinator for format-agnostic reduction. It takes
+    a pass that works on type T and returns a pass that works on type S,
+    by parsing S->T before the pass and dumping T->S after.
+
+    Example:
+        # delete_duplicates works on sequences
+        # Split(b"\\n") parses bytes into lines
+        # The composed pass deletes duplicate lines from bytes
+        line_dedup = compose(Split(b"\\n"), delete_duplicates)
+
+    If parsing fails, the composed pass returns immediately (no-op).
+    """
+
     @wraps(reduction_pass)
     async def wrapped_pass(problem: ReductionProblem[S]) -> None:
         view = problem.view(format)

shrinkray/passes/genericlanguages.py

@@ -3,9 +3,10 @@ Module of reduction passes designed for "things that look like programming langu
 """
 
 import re
+from collections.abc import Callable, Sized
 from functools import wraps
 from string import ascii_lowercase, ascii_uppercase
-from typing import AnyStr, Callable
+from typing import AnyStr
 
 import trio
 from attr import define
@@ -37,9 +38,9 @@ class Substring(Format[AnyStr, AnyStr]):
 
 
 class RegionReplacingPatches(Patches[dict[int, AnyStr], AnyStr]):
-    def __init__(self, regions):
+    def __init__(self, regions: list[tuple[int, int]]):
         assert regions
-        for (_, v), (u, _) in zip(regions, regions[1:]):
+        for (_, v), (u, _) in zip(regions, regions[1:], strict=False):
             assert v <= u
         self.regions = regions
 
@@ -69,15 +70,15 @@ class RegionReplacingPatches(Patches[dict[int, AnyStr], AnyStr]):
         return empty.join(parts)
 
     def size(self, patch):
-        total = 0
         for i, s in patch.items():
             u, v = self.regions[i]
             return v - u - len(s)
+        raise AssertionError(f"expected nonempty {patch=}")
 
 
 def regex_pass(
     pattern: AnyStr | re.Pattern[AnyStr],
-    flags: re.RegexFlag = 0,
+    flags: re.RegexFlag = re.RegexFlag.NOFLAG,
 ) -> Callable[[ReductionPass[AnyStr]], ReductionPass[AnyStr]]:
     if not isinstance(pattern, re.Pattern):
         pattern = re.compile(pattern, flags=flags)
@@ -129,6 +130,11 @@ def regex_pass(
 
 
 async def reduce_integer(problem: ReductionProblem[int]) -> None:
+    """Reduce an integer to its smallest interesting value.
+
+    Uses binary search to find the smallest integer that maintains
+    interestingness. Tries 0 first, then narrows down the range.
+    """
     assert problem.current_test_case >= 0
 
     if await problem.is_interesting(0):
@@ -166,11 +172,21 @@ class IntegerFormat(Format[bytes, int]):
 
 @regex_pass(b"[0-9]+")
 async def reduce_integer_literals(problem: ReductionProblem[bytes]) -> None:
+    """Reduce integer literals in source code to smaller values.
+
+    Finds numeric literals and tries to reduce each one independently
+    using binary search.
+    """
     await reduce_integer(problem.view(IntegerFormat()))
 
 
 @regex_pass(rb"[0-9]+ [*+-/] [0-9]+")
 async def combine_expressions(problem: ReductionProblem[bytes]) -> None:
+    """Evaluate and simplify simple arithmetic expressions.
+
+    Finds expressions like "2 + 3" and replaces them with their result "5".
+    Only handles basic integer arithmetic to avoid changing program semantics.
+    """
     try:
         # NB: Use of eval is safe, as everything passed to this is a simple
         # arithmetic expression. Would ideally replace with a guaranteed
@@ -184,18 +200,39 @@ async def combine_expressions(problem: ReductionProblem[bytes]) -> None:
 
 @regex_pass(rb'([\'"])\s*\1')
 async def merge_adjacent_strings(problem: ReductionProblem[bytes]) -> None:
+    """Remove empty string concatenations like '' '' or "" "".
+
+    These patterns (quote, whitespace, same quote) often result from
+    other reductions and can be eliminated entirely.
+    """
     await problem.is_interesting(b"")
 
 
 @regex_pass(rb"''|\"\"|false|\(\)|\[\]", re.IGNORECASE)
 async def replace_falsey_with_zero(problem: ReductionProblem[bytes]) -> None:
+    """Replace falsey values with 0.
+
+    Tries to replace empty strings, 'false', empty parentheses, and empty
+    brackets with the single character '0', which is shorter and often
+    equivalent in boolean contexts.
+    """
     await problem.is_interesting(b"0")
 
 
 async def simplify_brackets(problem: ReductionProblem[bytes]) -> None:
+    """Try to replace bracket types with simpler ones.
+
+    Attempts to replace {} with [] or (), and [] with (). This can
+    help normalize syntax when the specific bracket type doesn't matter.
+    """
     bracket_types = [b"[]", b"{}", b"()"]
 
-    patches = [dict(zip(u, v)) for u in bracket_types for v in bracket_types if u > v]
+    patches = [
+        dict(zip(u, v, strict=True))
+        for u in bracket_types
+        for v in bracket_types
+        if u > v
+    ]
 
     await apply_patches(problem, ByteReplacement(), patches)
 
@@ -203,11 +240,17 @@ async def simplify_brackets(problem: ReductionProblem[bytes]) -> None:
 IDENTIFIER = re.compile(rb"(\b[A-Za-z][A-Za-z0-9_]*\b)|([0-9]+)")
 
 
-def shortlex(s):
+def shortlex[T: Sized](s: T) -> tuple[int, T]:
     return (len(s), s)
 
 
 async def normalize_identifiers(problem: ReductionProblem[bytes]) -> None:
+    """Replace identifiers with shorter alternatives.
+
+    Finds all identifiers in the source and tries to replace longer ones
+    with shorter alternatives (single letters like 'a', 'b', etc.). This
+    normalizes variable/function names to minimal forms.
+    """
     identifiers = {m.group(0) for m in IDENTIFIER.finditer(problem.current_test_case)}
     replacements = set(identifiers)
 
@@ -253,6 +296,12 @@ def iter_indices(s, substring):
 
 
 async def cut_comments(problem: ReductionProblem[bytes], start, end, include_end=True):
+    """Remove comment-like regions bounded by start and end markers.
+
+    Finds all regions starting with 'start' and ending with 'end', then
+    tries to delete them. Used to remove comments from various languages.
+    If include_end is False, the end marker itself is not deleted.
+    """
     cuts = []
     target = problem.current_test_case
     # python comments
@@ -271,6 +320,11 @@ async def cut_comments(problem: ReductionProblem[bytes], start, end, include_end
 
 
 async def cut_comment_like_things(problem: ReductionProblem[bytes]):
+    """Remove common comment syntaxes from source code.
+
+    Tries to delete Python-style (#), C++-style (//), Python docstrings
+    (triple quotes), and C-style block comments (/* ... */).
+    """
     await cut_comments(problem, b"#", b"\n", include_end=False)
     await cut_comments(problem, b"//", b"\n", include_end=False)
     await cut_comments(problem, b'"""', b'"""')

shrinkray/passes/json.py

@@ -81,6 +81,12 @@ class DeleteIdentifiers(Patches[frozenset[str], Any]):
 
 
 async def delete_identifiers(problem: ReductionProblem[Any]):
+    """Remove object keys from JSON structures.
+
+    Finds all string keys used in any nested object and tries to remove
+    them. When a key is removed, it's deleted from all objects that
+    contain it throughout the JSON tree.
+    """
     identifiers = gather_identifiers(problem.current_test_case)
 
     await apply_patches(

shrinkray/passes/patching.py

@@ -1,24 +1,22 @@
 from abc import ABC, abstractmethod
+from collections.abc import Callable, Iterable, Sequence
 from enum import Enum
 from random import Random
-from typing import Any, Callable, Generic, Iterable, Sequence, TypeVar, cast
+from typing import Any, TypeVar, cast
 
 import trio
 
 from shrinkray.problem import ReductionProblem
 
-Seq = TypeVar("Seq", bound=Sequence[Any])
-T = TypeVar("T")
 
-PatchType = TypeVar("PatchType")
-TargetType = TypeVar("TargetType")
+Seq = TypeVar("Seq", bound=Sequence[Any])
 
 
 class Conflict(Exception):
     pass
 
 
-class Patches(Generic[PatchType, TargetType], ABC):
+class Patches[PatchType, TargetType](ABC):
     @property
     @abstractmethod
     def empty(self) -> PatchType: ...
@@ -33,7 +31,7 @@ class Patches(Generic[PatchType, TargetType], ABC):
     def size(self, patch: PatchType) -> int: ...
 
 
-class SetPatches(Patches[frozenset[T], TargetType]):
+class SetPatches[T, TargetType](Patches[frozenset[T], TargetType]):
     def __init__(self, apply: Callable[[frozenset[T], TargetType], TargetType]):
         self.__apply = apply
 
@@ -54,7 +52,7 @@ class SetPatches(Patches[frozenset[T], TargetType]):
         return len(patch)
 
 
-class ListPatches(Patches[list[T], TargetType]):
+class ListPatches[T, TargetType](Patches[list[T], TargetType]):
     def __init__(self, apply: Callable[[list[T], TargetType], TargetType]):
         self.__apply = apply
 
@@ -75,7 +73,7 @@ class ListPatches(Patches[list[T], TargetType]):
         return len(patch)
 
 
-class PatchApplier(Generic[PatchType, TargetType], ABC):
+class PatchApplier[PatchType, TargetType]:
     def __init__(
         self,
         patches: Patches[PatchType, TargetType],
@@ -91,55 +89,28 @@ class PatchApplier(Generic[PatchType, TargetType], ABC):
         self.__current_patch = self.__patches.empty
         self.__initial_test_case = problem.current_test_case
 
-    async def try_apply_patch(self, patch: PatchType) -> bool:
-        initial_patch = self.__current_patch
+    async def __possibly_become_merge_master(self):
         try:
-            combined_patch = self.__patches.combine(initial_patch, patch)
-        except Conflict:
+            self.__merge_lock.acquire_nowait()
+        except trio.WouldBlock:
             return False
-        if combined_patch == self.__current_patch:
-            return True
-        with_patch_applied = self.__patches.apply(
-            combined_patch, self.__initial_test_case
-        )
-        if with_patch_applied == self.__problem.current_test_case:
-            return True
-        if not await self.__problem.is_interesting(with_patch_applied):
-            return False
-        send_merge_result, receive_merge_result = trio.open_memory_channel(1)
-
-        sort_key = (self.__tick, self.__problem.sort_key(with_patch_applied))
-        self.__tick += 1
-
-        self.__merge_queue.append((sort_key, patch, send_merge_result))
-
-        async with self.__merge_lock:
-            if (
-                self.__current_patch == initial_patch
-                and len(self.__merge_queue) == 1
-                and self.__merge_queue[0][1] == patch
-                and self.__problem.sort_key(with_patch_applied)
-                <= self.__problem.sort_key(self.__problem.current_test_case)
-            ):
-                self.__current_patch = combined_patch
-                self.__merge_queue.clear()
-                return True
-
+        try:
             while self.__merge_queue:
                 base_patch = self.__current_patch
                 to_merge = len(self.__merge_queue)
 
                 async def can_merge(k):
-                    if k > to_merge:
-                        return False
+                    # find_large_integer doubles each time, and
+                    # if we call it then we know that can_merge(to_merge)
+                    # is False, so we should never hit this.
+                    assert k <= 2 * to_merge
                     try:
                         attempted_patch = self.__patches.combine(
-                            base_patch, *[p for _, p, _ in self.__merge_queue[:k]]
+                            base_patch,
+                            *[p for _, p, _ in self.__merge_queue[:k]],
                         )
                     except Conflict:
                         return False
-                    if attempted_patch == base_patch:
-                        return True
                     with_patch_applied = self.__patches.apply(
                         attempted_patch, self.__initial_test_case
                     )
@@ -163,10 +134,44 @@ class PatchApplier(Generic[PatchType, TargetType], ABC):
                     del self.__merge_queue[: merged + 1]
                 else:
                     del self.__merge_queue[:to_merge]
+        finally:
+            self.__merge_lock.release()
 
-        # This should always have been populated during the previous merge,
-        # either by us or someone else merging.
-        return receive_merge_result.receive_nowait()
+        return True
+
+    async def try_apply_patch(self, patch: PatchType) -> bool:
+        initial_patch = self.__current_patch
+        try:
+            combined_patch = self.__patches.combine(initial_patch, patch)
+        except Conflict:
+            return False
+        if combined_patch == self.__current_patch:
+            return True
+        with_patch_applied = self.__patches.apply(
+            combined_patch, self.__initial_test_case
+        )
+        if with_patch_applied == self.__problem.current_test_case:
+            return True
+        if not await self.__problem.is_interesting(with_patch_applied):
+            return False
+        send_merge_result, receive_merge_result = trio.open_memory_channel(1)
+
+        sort_key = (self.__tick, self.__problem.sort_key(with_patch_applied))
+        self.__tick += 1
+
+        self.__merge_queue.append((sort_key, patch, send_merge_result))
+
+        # If nobody else is merging the queue, that's our job now. This will
+        # run until the queue is fully cleared, including the job we just
+        # put on it.
+        if await self.__possibly_become_merge_master():
+            # This should always have been populated during the merge step we just
+            # performed, so we use a nowait here to ensure it doesn't hang on a
+            # bug.
+            return receive_merge_result.receive_nowait()
+        else:
+            # Wait to clear to merge queue.
+            return await receive_merge_result.receive()
 
 
 class Direction(Enum):
@@ -178,15 +183,18 @@ class Completed(Exception):
     pass
 
 
-async def apply_patches(
+async def apply_patches[PatchType, TargetType](
     problem: ReductionProblem[TargetType],
     patch_info: Patches[PatchType, TargetType],
     patches: Iterable[PatchType],
 ) -> None:
-    if await problem.is_interesting(
-        patch_info.apply(patch_info.combine(*patches), problem.current_test_case)
-    ):
-        return
+    try:
+        if await problem.is_interesting(
+            patch_info.apply(patch_info.combine(*patches), problem.current_test_case)
+        ):
+            return
+    except Conflict:
+        pass
 
     applier = PatchApplier(patch_info, problem)
 
@@ -200,10 +208,10 @@ async def apply_patches(
     send_patches.close()
 
     async with trio.open_nursery() as nursery:
-        for _ in range(problem.work.parallelism):
+        for _i in range(problem.work.parallelism):
 
             @nursery.start_soon
-            async def _():
+            async def worker() -> None:
                 while True:
                     try:
                         patch = await receive_patches.receive()
@@ -234,7 +242,7 @@ class LazyMutableRange:
         return result
 
 
-def lazy_shuffle(seq: Sequence[T], rnd: Random) -> Iterable[T]:
+def lazy_shuffle[T](seq: Sequence[T], rnd: Random) -> Iterable[T]:
     indices = LazyMutableRange(len(seq))
     while indices:
         j = len(indices) - 1