crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/util_test.py

@@ -0,0 +1,173 @@
+import sys
+import traceback
+import types
+from dataclasses import dataclass
+from enum import Enum
+from inspect import signature
+from typing import Union
+
+import numpy
+import pytest
+
+from crosshair.tracers import PatchingModule
+from crosshair.util import (
+    CrossHairInternal,
+    DynamicScopeVar,
+    eval_friendly_repr,
+    format_boundargs,
+    imported_alternative,
+    is_pure_python,
+    renamed_function,
+    sourcelines,
+)
+
+
+def test_is_pure_python_functions():
+    assert is_pure_python(is_pure_python)
+    assert not is_pure_python(map)
+
+
+def test_is_pure_python_classes():
+    class RegularClass:
+        pass
+
+    class ClassWithSlots:
+        __slots__ = ("x",)
+
+    assert is_pure_python(RegularClass)
+    assert is_pure_python(ClassWithSlots)
+    assert not is_pure_python(list)
+
+
+def test_is_pure_python_other_stuff():
+    assert is_pure_python(7)
+    assert is_pure_python(pytest)
+
+
+def test_dynamic_scope_var_basic():
+    var = DynamicScopeVar(int, "height")
+    with var.open(7):
+        assert var.get() == 7
+
+
+def test_dynamic_scope_var_bsic():
+    var = DynamicScopeVar(int, "height")
+    assert var.get_if_in_scope() is None
+    with var.open(7):
+        assert var.get_if_in_scope() == 7
+    assert var.get_if_in_scope() is None
+
+
+def test_dynamic_scope_var_error_cases():
+    var = DynamicScopeVar(int, "height")
+    with var.open(100):
+        with pytest.raises(AssertionError, match="Already in a height context"):
+            with var.open(500, reentrant=False):
+                pass
+    with pytest.raises(AssertionError, match="Not in a height context"):
+        var.get()
+
+
+def test_dynamic_scope_var_with_exception():
+    var = DynamicScopeVar(int, "height")
+    try:
+        with var.open(7):
+            raise NameError()
+    except NameError:
+        pass
+    assert var.get_if_in_scope() is None
+
+
+def test_imported_alternative():
+    import heapq
+
+    assert type(heapq.heapify) == types.BuiltinFunctionType
+    with imported_alternative("heapq", ("_heapq",)):
+        assert type(heapq.heapify) == types.FunctionType
+    assert type(heapq.heapify) == types.BuiltinFunctionType
+
+
+class UnhashableCallable:
+    def __hash__(self):
+        raise CrossHairInternal("Do not hash")
+
+    def __call__(self):
+        return 42
+
+
+def test_sourcelines_on_unhashable_callable():
+    # Ensure we never trigger hashing when getting source code.
+    sourcelines(UnhashableCallable())
+
+
+def eat_things(p1, *varp, kw1=4, kw2="default", **varkw):
+    pass
+
+
+def test_format_boundargs():
+    bound = signature(eat_things).bind(1, 2, 3, kw2=5, other=6)
+    assert format_boundargs(bound) == "1, 2, 3, kw1=4, kw2=5, other=6"
+
+
+class Color(Enum):
+    RED = 0
+
+
+@dataclass
+class Pair:
+    x: Union["Pair", type, None] = None
+    y: Union["Pair", type, None] = None
+
+
+def test_eval_friendly_repr():
+    from crosshair.opcode_intercept import FormatValueInterceptor
+    from crosshair.tracers import COMPOSITE_TRACER, NoTracing, PushedModule
+
+    with COMPOSITE_TRACER, PushedModule(PatchingModule()), PushedModule(
+        FormatValueInterceptor()
+    ), NoTracing():
+        # Class
+        assert eval_friendly_repr(Color) == "Color"
+        # Pure-python method:
+        assert (
+            eval_friendly_repr(UnhashableCallable.__hash__)
+            == "UnhashableCallable.__hash__"
+        )
+        # Builtin function:
+        assert eval_friendly_repr(print) == "print"
+        # Object:
+        assert eval_friendly_repr(object()) == "object()"
+        # Special float values:
+        assert eval_friendly_repr(float("nan")) == 'float("nan")'
+        # MethodDescriptorType
+        assert isinstance(str.join, types.MethodDescriptorType)
+        assert eval_friendly_repr(str.join) == "str.join"
+        # enums:
+        assert eval_friendly_repr(Color.RED) == "Color.RED"
+        # basic dataclass
+        assert eval_friendly_repr(Pair(None, None)) == "Pair(x=None, y=None)"
+        # do not attempt to re-use ReferencedIdentifiers
+        assert eval_friendly_repr(Pair(Pair, Pair)) == "Pair(x=Pair, y=Pair)"
+        # Preserve identical objects
+        a = Pair()
+        assert (
+            eval_friendly_repr(Pair(a, a)) == "Pair(x=v1:=Pair(x=None, y=None), y=v1)"
+        )
+
+        # We return to original repr() behaviors afterwards:
+        assert repr(float("nan")) == "nan"
+        assert repr(Color.RED) == "<Color.RED: 0>"
+
+
+def test_renamed_function():
+    def crash_on_seven(x):
+        if x == 7:
+            raise IOError
+        return x
+
+    hello = renamed_function(crash_on_seven, "hello")
+    hello(6)
+    try:
+        hello(7)
+    except IOError as e:
+        assert traceback.extract_tb(e.__traceback__)[-1].name == "hello"

crosshair/watcher.py

@@ -0,0 +1,307 @@
+import base64
+import binascii
+import multiprocessing
+import os
+import pickle
+import queue
+import subprocess
+import sys
+import threading
+import time
+import traceback
+import zlib
+from pathlib import Path
+from queue import Queue
+from typing import (
+    Any,
+    Counter,
+    Dict,
+    Iterable,
+    Iterator,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
+
+from crosshair.auditwall import engage_auditwall, opened_auditwall
+from crosshair.core_and_libs import (
+    AnalysisMessage,
+    MessageType,
+    analyze_module,
+    run_checkables,
+)
+from crosshair.fnutil import NotFound, walk_paths
+from crosshair.options import AnalysisOptionSet
+from crosshair.util import (
+    CrossHairInternal,
+    ErrorDuringImport,
+    debug,
+    load_file,
+    set_debug,
+)
+
+# Use "spawn" in stead of fork() because we've already imported the code we're watching:
+multiproc_spawn = multiprocessing.get_context("spawn")
+
+
+def mtime(path: Path) -> Optional[float]:
+    try:
+        return path.stat().st_mtime
+    except FileNotFoundError:
+        return None
+
+
+WorkItemInput = Tuple[Path, AnalysisOptionSet, float]  # (file, opts, deadline)
+WorkItemOutput = Tuple[Path, Counter[str], List[AnalysisMessage]]
+
+
+def serialize(obj: object) -> str:
+    return str(base64.b64encode(zlib.compress(pickle.dumps(obj))), "ascii")
+
+
+def deserialize(data: Union[bytes, str]) -> Any:
+    try:
+        return pickle.loads(zlib.decompress(base64.b64decode(data)))
+    except binascii.Error:
+        debug(f"Unable to deserialize this data: {data!r}")
+        raise
+
+
+def import_error_msg(err: ErrorDuringImport) -> AnalysisMessage:
+    cause = err.__cause__ if err.__cause__ else err
+    tb = cause.__traceback__
+    if tb:
+        filename, line = tb.tb_frame.f_code.co_filename, tb.tb_lineno
+        tbstr = "".join(traceback.format_tb(tb))
+    else:
+        filename, line = "<unknown>", 0
+        tbstr = ""
+    return AnalysisMessage(MessageType.IMPORT_ERR, str(cause), filename, line, 0, tbstr)
+
+
+def pool_worker_process_item(
+    item: WorkItemInput,
+) -> Tuple[Counter[str], List[AnalysisMessage]]:
+    filename, options, deadline = item
+    stats: Counter[str] = Counter()
+    options.stats = stats
+    try:
+        module = load_file(str(filename))
+    except NotFound as e:
+        debug(f'Not analyzing "{filename}" because sub-module import failed: {e}')
+        return (stats, [])
+    except ErrorDuringImport as e:
+        debug(f'Not analyzing "{filename}" because import failed: {e}')
+        return (stats, [import_error_msg(e)])
+    messages = run_checkables(analyze_module(module, options))
+    return (stats, messages)
+
+
+class PoolWorkerShell(threading.Thread):
+    def __init__(
+        self, input_item: WorkItemInput, results: "queue.Queue[WorkItemOutput]"
+    ):
+        self.input_item = input_item
+        self.results = results
+        self.proc: Optional[subprocess.Popen] = None
+        super().__init__()
+
+    def run(self) -> None:
+        encoded_input = serialize(self.input_item)
+        worker_args = [
+            sys.executable,
+            "-c",
+            f"import crosshair.watcher; crosshair.watcher.pool_worker_main()",
+            encoded_input,
+        ]
+        self.proc = subprocess.Popen(
+            worker_args,
+            stdin=subprocess.DEVNULL,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        (stdout, _stderr) = self.proc.communicate(b"")
+        if stdout:
+            last_line = stdout.splitlines()[-1]  # (in case of spurious print()s)
+            self.results.put(deserialize(last_line))
+
+
+def pool_worker_main() -> None:
+    item: WorkItemInput = deserialize(sys.argv[-1])
+    filename = item[0]
+    try:
+        if hasattr(os, "nice"):  # analysis should run at a low priority
+            # Note that the following "type: ignore" is ONLY required for mypy on
+            # Windows, where the nice function does not exist:
+            os.nice(10)  # type: ignore
+        set_debug(False)
+        engage_auditwall()
+        (stats, messages) = pool_worker_process_item(item)
+        output: WorkItemOutput = (filename, stats, messages)
+        print(serialize(output))
+    except BaseException as e:
+        raise CrossHairInternal("Worker failed while analyzing " + str(filename)) from e
+
+
+class Pool:
+    _workers: List[Tuple[PoolWorkerShell, WorkItemInput]]
+    _work: List[WorkItemInput]
+    _results: "Queue[WorkItemOutput]"
+    _max_processes: int
+
+    def __init__(self, max_processes: int) -> None:
+        self._workers = []
+        self._work = []
+        self._results = Queue()
+        self._max_processes = max_processes
+
+    def _spawn_workers(self):
+        work_list = self._work
+        workers = self._workers
+        while work_list and len(self._workers) < self._max_processes:
+            work_item = work_list.pop()
+            # NOTE: We are martialling data manually.
+            # Earlier versions used multiprocessing and Queues, but
+            # multiprocessing.Process is incompatible with pygls on windows
+            # (something with the async blocking on stdin, which must remain open
+            # in the child).
+
+            thread = PoolWorkerShell(work_item, self._results)
+            workers.append((thread, work_item))
+            thread.start()
+
+    def _prune_workers(self, curtime: float) -> None:
+        for worker, item in self._workers:
+            (_, _, deadline) = item
+            if worker.is_alive() and curtime > deadline and worker.proc is not None:
+                debug("Killing worker over deadline", worker)
+                worker.proc.terminate()
+                time.sleep(0.5)
+                if worker.is_alive():
+                    worker.proc.kill()
+                    worker.join()
+        self._workers = [(w, i) for w, i in self._workers if w.is_alive()]
+
+    def terminate(self) -> None:
+        self._prune_workers(float("+inf"))
+        self._work = []
+
+    def garden_workers(self) -> None:
+        self._prune_workers(time.time())
+        self._spawn_workers()
+
+    def is_working(self) -> bool:
+        return bool(self._workers or self._work)
+
+    def submit(self, item: WorkItemInput) -> None:
+        self._work.append(item)
+
+    def has_result(self) -> bool:
+        return not self._results.empty()
+
+    def get_result(self, timeout: float) -> Optional[WorkItemOutput]:
+        try:
+            return self._results.get(timeout=timeout)
+        except queue.Empty:
+            return None
+
+
+class Watcher:
+    _paths: Set[Path]
+    _pool: Pool
+    _modtimes: Dict[Path, float]
+    _options: AnalysisOptionSet
+    _next_file_check: float = 0.0
+    _change_flag: bool = False
+    _stop_flag: bool = False
+
+    def __init__(
+        self, files: Iterable[Path], options: AnalysisOptionSet = AnalysisOptionSet()
+    ):
+        self._paths = set(files)
+        self._pool = self.startpool()
+        self._modtimes = {}
+        self._options = options
+
+    def shutdown(self):
+        self._stop_flag = True
+
+    def update_paths(self, paths: Iterable[Path]):
+        self._paths = set(paths)
+
+    def startpool(self) -> Pool:
+        return Pool(multiprocessing.cpu_count() - 1)
+
+    def run_iteration(
+        self, max_uninteresting_iterations=5
+    ) -> Iterator[Tuple[Counter[str], List[AnalysisMessage]]]:
+        debug(
+            f"starting pass with max_uninteresting_iterations={max_uninteresting_iterations}"
+        )
+        debug("Files:", self._modtimes.keys())
+        pool = self._pool
+        for filename, _ in sorted(self._modtimes.items(), key=lambda pair: -pair[1]):
+            worker_timeout = max(
+                10.0, max_uninteresting_iterations * 1_000.0
+            )  # TODO: times 1000? is that right?
+            iter_options = AnalysisOptionSet(
+                max_uninteresting_iterations=max_uninteresting_iterations,
+            )
+            options = self._options.overlay(iter_options)
+            pool.submit((filename, options, time.time() + worker_timeout))
+
+        pool.garden_workers()
+        if not pool.is_working():
+            # Unusual case where there is nothing to do:
+            time.sleep(1.5)
+            self.handle_periodic()  # (keep checking for changes!)
+            yield (Counter(), [])
+            return
+        while pool.is_working():
+            result = pool.get_result(timeout=1.0)
+            if result is not None:
+                (_, counters, messages) = result
+                yield (counters, messages)
+                if pool.has_result():
+                    continue
+            if self.handle_periodic():
+                yield (Counter(), [])  # to break the parent from waiting
+                return
+            pool.garden_workers()
+        debug("Worker pool tasks complete")
+
+    def handle_periodic(self) -> bool:
+        if self._stop_flag:
+            debug("Aborting iteration on shutdown request")
+            self._pool.terminate()
+            return True
+        if time.time() >= self._next_file_check:
+            self._next_file_check = time.time() + 1.0
+            if self.check_changed():
+                self._change_flag = True
+                debug("Aborting iteration on change detection")
+                self._pool.terminate()
+                self._pool = self.startpool()
+                return True
+        return False
+
+    def check_changed(self) -> bool:
+        unchecked_modtimes = self._modtimes.copy()
+        changed = False
+        for curfile in walk_paths(self._paths, ignore_missing=True):
+            cur_mtime = mtime(curfile)
+            if cur_mtime is None:
+                # Unlikely; race condition on an interleaved file delete
+                continue
+            if cur_mtime == unchecked_modtimes.pop(curfile, None):
+                continue
+            changed = True
+            self._modtimes[curfile] = cur_mtime
+        if unchecked_modtimes:
+            # Files known but not found; something was deleted
+            changed = True
+            for delfile in unchecked_modtimes.keys():
+                del self._modtimes[delfile]
+        return changed

crosshair/watcher_test.py

@@ -0,0 +1,107 @@
+import sys
+import time
+from collections import Counter
+from pathlib import Path
+
+import pytest
+
+from crosshair.statespace import MessageType
+from crosshair.test_util import simplefs
+from crosshair.watcher import Watcher
+
+# TODO: DRY a bit with main_test.py
+
+
+@pytest.fixture(autouse=True)
+def rewind_modules():
+    defined_modules = list(sys.modules.keys())
+    yield None
+    for name, module in list(sys.modules.items()):
+        # Some standard library modules aren't happy with getting reloaded.
+        if name.startswith("multiprocessing"):
+            continue
+        if name not in defined_modules:
+            del sys.modules[name]
+
+
+BUGGY_FOO = {
+    "foo.py": """
+def foofn(x: int) -> int:
+  ''' post: _ == x '''
+  print("this print does not confuse the watcher")
+  return x + 1
+"""
+}
+
+CORRECT_FOO = {
+    "foo.py": """
+def foofn(x: int) -> int:
+  ''' post: _ == 1 + x '''
+  return x + 1
+"""
+}
+
+BAD_SYNTAX_FOO = {
+    "foo.py": """
+def foofn(x: int) -> int:
+  ''' post: _ == x '''
+  return $ x + 1
+"""
+}
+
+EMPTY_BAR = {
+    "bar.py": """
+# Nothing here
+"""
+}
+
+
+def test_added_file(tmp_path: Path):
+    simplefs(tmp_path, CORRECT_FOO)
+    watcher = Watcher([tmp_path])
+    assert watcher.check_changed()
+    assert not watcher.check_changed()
+    simplefs(tmp_path, EMPTY_BAR)
+    assert watcher.check_changed()
+
+
+def test_added_file_to_empty_dir(tmp_path: Path):
+    watcher = Watcher([tmp_path])
+    assert list(watcher.run_iteration()) == [(Counter(), [])]
+    simplefs(tmp_path, BUGGY_FOO)  # Add new file.
+    watcher._next_file_check = time.time() - 1
+    # Detect file (yields empty result to wake up the loop)
+    assert list(watcher.run_iteration()) == [(Counter(), [])]
+    # Find bug in new file after restart.
+    results = list(watcher.run_iteration())
+    assert len(results) == 1
+    assert [m.state for m in results[0][1]] == [MessageType.POST_FAIL]
+
+
+def test_modified_file(tmp_path: Path):
+    simplefs(tmp_path, CORRECT_FOO)
+    watcher = Watcher([tmp_path])
+    assert watcher.check_changed()
+    assert not watcher.check_changed()
+    time.sleep(0.01)  # Ensure mtime is actually different!
+    simplefs(tmp_path, BUGGY_FOO)
+    assert watcher.check_changed()
+    assert not watcher.check_changed()
+
+
+def test_removed_file(tmp_path: Path):
+    simplefs(tmp_path, CORRECT_FOO)
+    simplefs(tmp_path, EMPTY_BAR)
+    watcher = Watcher([tmp_path])
+    assert watcher.check_changed()
+    assert not watcher.check_changed()
+    (tmp_path / "bar.py").unlink()
+    assert watcher.check_changed()
+
+
+def test_removed_file_given_as_argument(tmp_path: Path):
+    simplefs(tmp_path, CORRECT_FOO)
+    watcher = Watcher([tmp_path / "foo.py"])
+    assert watcher.check_changed()
+    (tmp_path / "foo.py").unlink()
+    assert watcher.check_changed()

crosshair/z3util.py

@@ -0,0 +1,76 @@
+import z3  # type: ignore
+from z3 import (
+    BoolRef,
+    BoolSort,
+    ExprRef,
+    IntNumRef,
+    IntSort,
+    Z3_mk_and,
+    Z3_mk_eq,
+    Z3_mk_ge,
+    Z3_mk_gt,
+    Z3_mk_not,
+    Z3_mk_numeral,
+    Z3_mk_or,
+    Z3_solver_assert,
+)
+from z3.z3 import _to_ast_array  # type: ignore
+
+ctx = z3.main_ctx()
+ctx_ref = ctx.ref()
+bool_sort = BoolSort(ctx)
+int_sort_ast = IntSort(ctx).ast
+
+
+def z3Eq(a: ExprRef, b: ExprRef) -> BoolRef:
+    # return a == b
+    return BoolRef(Z3_mk_eq(ctx_ref, a.as_ast(), b.as_ast()), ctx)
+
+
+def z3Gt(a: IntNumRef, b: IntNumRef) -> BoolRef:
+    # return a > b
+    return BoolRef(Z3_mk_gt(ctx_ref, a.as_ast(), b.as_ast()), ctx)
+
+
+def z3Ge(a: IntNumRef, b: IntNumRef) -> BoolRef:
+    # return a >= b
+    return BoolRef(Z3_mk_ge(ctx_ref, a.as_ast(), b.as_ast()), ctx)
+
+
+def z3IntVal(x: int) -> z3.IntNumRef:
+    # return z3.IntVal(x)
+    # Use __index__ to get a regular integer for int subtypes (e.g. enums)
+    return IntNumRef(Z3_mk_numeral(ctx_ref, x.__index__().__str__(), int_sort_ast), ctx)
+
+
+def z3Or(*exprs):
+    # return z3.Or(*exprs)
+    (args, sz) = _to_ast_array(exprs)
+    return BoolRef(Z3_mk_or(ctx.ref(), sz, args), ctx)
+
+
+def z3And(*exprs):
+    # return z3.And(*exprs)
+    (args, sz) = _to_ast_array(exprs)
+    return BoolRef(Z3_mk_and(ctx.ref(), sz, args), ctx)
+
+
+def z3Aassert(solver, expr):
+    # return solver.add(expr)
+    assert isinstance(expr, z3.ExprRef)
+    Z3_solver_assert(ctx_ref, solver.solver, expr.as_ast())
+
+
+def z3Not(expr):
+    # return z3.Not(expr)
+    if z3.is_not(expr):
+        return expr.arg(0)
+    else:
+        return BoolRef(Z3_mk_not(ctx_ref, expr.as_ast()), ctx)
+
+
+def z3PopNot(expr):
+    if z3.is_not(expr):
+        return (False, expr.arg(0))
+    else:
+        return (True, expr)

crosshair/z3util_test.py

@@ -0,0 +1,11 @@
+from enum import IntEnum
+
+from crosshair.z3util import z3IntVal
+
+
+class IntSubClass(IntEnum):
+    FIRST = 1
+
+
+def test_intval_on_int_enum():
+    z3IntVal(IntSubClass.FIRST)