crosshair-tool 0.0.99__cp312-cp312-macosx_10_13_x86_64.whl

crosshair/libimpl/codecslib.py

@@ -0,0 +1,86 @@
+import codecs
+
+from crosshair import NoTracing, register_patch
+from crosshair.core import class_with_realized_methods, realize, with_realized_args
+from crosshair.libimpl.encodings import codec_search
+from crosshair.util import is_iterable
+
+
+class RealizingCodecInfo(codecs.CodecInfo):
+    def __new__(cls, c: codecs.CodecInfo):
+        encode = with_realized_args(c.encode)
+        decode = with_realized_args(c.decode)
+        streamreader = class_with_realized_methods(c.streamreader)
+        streamwriter = class_with_realized_methods(c.streamwriter)
+        incrementaldecoder = class_with_realized_methods(c.incrementaldecoder)
+        incrementalencoder = class_with_realized_methods(c.incrementalencoder)
+        return codecs.CodecInfo(
+            encode,
+            decode,
+            streamreader=streamreader,
+            streamwriter=streamwriter,
+            incrementalencoder=incrementalencoder,
+            incrementaldecoder=incrementaldecoder,
+            name=c.name,
+        )
+
+
+def _decode(obj, encoding="utf-8", errors="strict"):
+    errors = realize(errors)
+    (out, _len_consumed) = _getdecoder(encoding)(obj, errors)
+    return out
+
+
+def _encode(obj, encoding="utf-8", errors="strict"):
+    with NoTracing():
+        errors = realize(errors)
+        if "\x00" in errors:
+            raise ValueError
+    (out, _len_consumed) = _getencoder(encoding)(obj, errors)
+    return out
+
+
+def _getencoder(encoding):
+    return _lookup(encoding).encode
+
+
+def _getdecoder(encoding):
+    return _lookup(encoding).decode
+
+
+def _getincrementaldecoder(encoding):
+    return _lookup(encoding).incrementaldecoder
+
+
+def _getincrementalencoder(encoding):
+    return _lookup(encoding).incrementalencoder
+
+
+def _getreader(encoding):
+    return _lookup(encoding).streamreader
+
+
+def _getwriter(encoding):
+    return _lookup(encoding).streamwriter
+
+
+def _lookup(encoding: str) -> codecs.CodecInfo:
+    with NoTracing():
+        encoding = realize(encoding)
+        try:
+            return codecs.lookup("crosshair_" + encoding)
+        except LookupError:
+            return RealizingCodecInfo(codecs.lookup(encoding))
+
+
+def make_registrations() -> None:
+    codecs.register(codec_search)
+    register_patch(codecs.decode, _decode)
+    register_patch(codecs.getencoder, _getencoder)
+    register_patch(codecs.getdecoder, _getdecoder)
+    register_patch(codecs.getincrementalencoder, _getincrementalencoder)
+    register_patch(codecs.getincrementaldecoder, _getincrementaldecoder)
+    register_patch(codecs.getreader, _getreader)
+    register_patch(codecs.getwriter, _getwriter)
+    register_patch(codecs.encode, _encode)
+    register_patch(codecs.lookup, _lookup)

crosshair/libimpl/codecslib_test.py

@@ -0,0 +1,86 @@
+import codecs
+import io
+import sys
+
+import pytest
+
+from crosshair.core import proxy_for_type
+from crosshair.core_and_libs import ResumedTracing, standalone_statespace
+from crosshair.libimpl.builtinslib import LazyIntSymbolicStr, SymbolicBytes, SymbolicInt
+from crosshair.options import AnalysisOptionSet
+from crosshair.statespace import POST_FAIL, MessageType
+from crosshair.test_util import check_states
+
+
+def test_encode_strict(space):
+    with ResumedTracing():
+        with pytest.raises(UnicodeError):
+            codecs.encode("Â", "ascii")
+
+
+def test_encode_utf8_literal(space):
+    with ResumedTracing():
+        assert codecs.encode("Â", "utf-8") == b"\xc3\x82"
+
+
+def test_encode_utf8_symbolic_char(space):
+    cp = SymbolicInt("cp")
+    with ResumedTracing():
+        space.add(cp >= ord("a"))
+        space.add(cp <= ord("z"))
+        encoded = codecs.encode(chr(cp), "utf-8")
+    assert isinstance(encoded, SymbolicBytes)
+    byte_value = encoded[0]
+    with ResumedTracing():
+        assert space.is_possible(byte_value == ord("a"))
+        assert space.is_possible(byte_value == ord("b"))
+
+
+def test_decode_utf8_symbolic_char(space):
+    cp = SymbolicInt("cp")
+    with ResumedTracing():
+        space.add(cp >= ord("a"))
+        space.add(cp <= ord("z"))
+        decoded = codecs.decode(SymbolicBytes([cp]), "utf-8")
+    assert isinstance(decoded, LazyIntSymbolicStr)
+    with ResumedTracing():
+        assert space.is_possible(decoded._codepoints[0] == ord("a"))
+        assert space.is_possible(decoded._codepoints[0] == ord("b"))
+
+
+def test_unsupported_codec_encode(space):
+    s = proxy_for_type(str, "s")
+    with ResumedTracing():
+        s.encode("cp858")
+
+
+def test_unsupported_codec_streamwriter(space):
+    s = proxy_for_type(str, "s")
+    buf = bytearray()
+    with ResumedTracing():
+        codecs.getwriter("cp858")(io.BytesIO(buf)).write(s)
+
+
+@pytest.mark.xfail(reason="not yet implemented")
+def test_supported_codec_streamwriter(space):
+    s = proxy_for_type(str, "s")
+    with ResumedTracing():
+        space.add(len(s) == 1)
+        buf = bytearray()
+        codecs.getwriter("ascii")(io.BytesIO(buf)).write(s)
+        space.is_possible(buf[0] == ord("x"))
+
+
+@pytest.mark.skipif(
+    sys.version_info >= (3, 13),
+    reason="Need to intercept UnicodeDecodeError.str in 3.13+",
+)
+def test_decode_e2e():
+    def f(byts: bytes) -> str:
+        """
+        post: _ != 'Â'
+        raises: UnicodeDecodeError
+        """
+        return byts.decode("utf-8", errors="strict")
+
+    check_states(f, POST_FAIL)

crosshair/libimpl/collectionslib.py

@@ -0,0 +1,264 @@
+import collections
+import sys
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    Iterable,
+    KeysView,
+    List,
+    Optional,
+    Set,
+    Tuple,
+    TypeVar,
+    Union,
+    ValuesView,
+)
+
+from crosshair import register_type
+from crosshair.core import realize
+from crosshair.tracers import NoTracing, ResumedTracing
+from crosshair.util import CrossHairValue, is_iterable
+
+T = TypeVar("T")
+
+
+class ListBasedDeque(collections.abc.MutableSequence, CrossHairValue, Generic[T]):
+    def __init__(self, contents: List[T], maxlen: Optional[int] = None):
+        self._contents = contents
+        self._maxlen = maxlen
+
+    def __ch_pytype__(self):
+        return collections.deque
+
+    def __ch_realize__(self):
+        with ResumedTracing():
+            return collections.deque(self._contents, maxlen=realize(self._maxlen))
+
+    def __add__(self, other):
+        if not isinstance(other, collections.deque):
+            raise TypeError
+        ret = self.copy()
+        ret.extend(other)
+        return ret
+
+    def __eq__(self, other: object) -> bool:
+        with NoTracing():
+            mycontents = self._contents
+            if isinstance(other, ListBasedDeque):
+                with ResumedTracing():
+                    return mycontents == other._contents
+            elif isinstance(other, collections.deque):
+                with ResumedTracing():
+                    return mycontents == list(other)
+            return False
+
+    def __len__(self) -> int:
+        return len(self._contents)
+
+    def __mul__(self, count):
+        if not isinstance(count, int):
+            raise TypeError
+        ret = ListBasedDeque([], self._maxlen)
+        for _ in range(count):
+            ret.extend(self._contents)
+        return ret
+
+    def __repr__(self) -> str:
+        return repr(realize(self))
+
+    def __getitem__(self, k):
+        if isinstance(k, slice):  # slicing isn't supported on deque
+            raise TypeError
+        return self._contents.__getitem__(k)
+
+    def __setitem__(self, k, v):
+        if isinstance(k, slice):  # slicing isn't supported on deque
+            raise TypeError
+        return self._contents.__setitem__(k, v)
+
+    def __delitem__(self, k):
+        if isinstance(k, slice):  # slicing isn't supported on deque
+            raise TypeError
+        return self._contents.__delitem__(k)
+
+    def _has_room(self) -> bool:
+        maxlen = self._maxlen
+        return maxlen is None or len(self._contents) < maxlen
+
+    def appendleft(self, item: T) -> None:
+        if self._has_room():
+            self._contents = [item] + self._contents
+        else:
+            del self._contents[-1]
+            self._contents = [item] + self._contents
+
+    def append(self, item: T) -> None:
+        if self._has_room():
+            self._contents = self._contents + [item]
+        else:
+            del self._contents[0]
+            self._contents = self._contents + [item]
+
+    def clear(self) -> None:
+        self._contents = []
+
+    def copy(self):
+        return ListBasedDeque(self._contents[:], self._maxlen)
+
+    def count(self, item: T) -> int:
+        c = 0
+        for i in self._contents:
+            if i == item:
+                c += 1
+        return c
+
+    def extend(self, items: Iterable[T]) -> None:
+        if not is_iterable(items):
+            raise TypeError
+        self._contents += list(items)
+
+    def extendleft(self, items: Iterable[T]) -> None:
+        if not is_iterable(items):
+            raise TypeError
+        prefix = list(items)
+        prefix.reverse()
+        self._contents = prefix + self._contents
+
+    if sys.version_info >= (3, 14):
+
+        def index(self, item: T, *bounds) -> int:
+            try:
+                return self._contents.index(item, *bounds)
+            except ValueError as exc:
+                exc.args = ("deque.index(x): x not in deque",)
+                raise
+
+    else:
+
+        def index(self, item: T, *bounds) -> int:
+            return self._contents.index(item, *bounds)
+
+    def insert(self, index: int, item: T) -> None:
+        self._contents.insert(index, item)
+
+    def pop(self) -> T:  # type: ignore
+        x = self._contents[-1]
+        del self._contents[-1]
+        return x
+
+    def popleft(self) -> T:
+        x = self._contents[0]
+        del self._contents[0]
+        return x
+
+    def remove(self, item: T) -> None:
+        self._contents.remove(item)
+
+    def reverse(self) -> None:
+        self._contents.reverse()
+
+    def rotate(self, n: int = 1) -> None:
+        if not self._contents or n % len(self._contents) == 0:
+            return
+        self._contents = (
+            self._contents[-n % len(self._contents) :]
+            + self._contents[: -n % len(self._contents)]
+        )
+
+    def maxlen(self) -> Optional[int]:
+        return self._maxlen
+
+
+class PureDefaultDict(collections.abc.MutableMapping, CrossHairValue):
+    def __init__(self, factory, internal):
+        self.default_factory = factory
+        self._internal = internal
+
+    def __ch_pytype__(self):
+        return collections.defaultdict
+
+    def __ch_realize__(self):
+        with ResumedTracing():
+            return collections.defaultdict(self.default_factory, self._internal)
+
+    def __getitem__(self, k):
+        try:
+            return self._internal.__getitem__(k)
+        except KeyError:
+            return self.__missing__(k)
+
+    def __setitem__(self, k, v):
+        return self._internal.__setitem__(k, v)
+
+    def __delitem__(self, k):
+        return self._internal.__delitem__(k)
+
+    def __iter__(self):
+        return self._internal.__iter__()
+
+    def __len__(self):
+        return self._internal.__len__()
+
+    def __repr__(self):
+        return "defaultdict({!r}, {!r})".format(self.default_factory, self._internal)
+
+    def __missing__(self, k):
+        if self.default_factory is None:
+            raise KeyError(k)
+        value = self.default_factory()
+        self._internal[k] = value
+        return value
+
+
+def make_registrations():
+    register_type(collections.defaultdict, lambda p, kt=Any, vt=Any: PureDefaultDict(p(Optional[Callable[[], vt]], "_initalizer"), p(Dict[kt, vt])))  # type: ignore
+    register_type(collections.ChainMap, lambda p, kt=Any, vt=Any: collections.ChainMap(*p(Tuple[Dict[kt, vt], ...])))  # type: ignore
+    register_type(collections.abc.Mapping, lambda p, kt=Any, vt=Any: p(Dict[kt, vt]))  # type: ignore
+    register_type(collections.abc.MutableMapping, lambda p, kt=Any, vt=Any: p(Dict[kt, vt]))  # type: ignore
+    register_type(collections.OrderedDict, lambda p, kt=Any, vt=Any: collections.OrderedDict(p(Dict[kt, vt])))  # type: ignore
+    # TODO: This implementation of Counter probably over-realizes the symbolic map it is given:
+    register_type(collections.Counter, lambda p, t=Any: collections.Counter(p(Dict[t, int])))  # type: ignore
+    # TODO: MappingView is missing
+    register_type(
+        collections.abc.ItemsView,
+        lambda p, k=Any, v=Any: p(Dict.__getitem__((k, v))).items(),
+    )
+    register_type(
+        collections.abc.MappingView,
+        lambda p, t=Any: p(
+            Union[
+                KeysView.__getitem__((t,)),
+                ValuesView.__getitem__((t,)),
+            ]
+        ),
+    )
+    register_type(
+        collections.abc.KeysView, lambda p, t=Any: p(Dict.__getitem__((t, Any))).keys()
+    )
+    register_type(
+        collections.abc.ValuesView,
+        lambda p, t=Any: p(Dict.__getitem__((Any, t))).values(),
+    )
+
+    register_type(collections.abc.Container, lambda p, t=Any: p(Tuple[t, ...]))
+    register_type(collections.abc.Collection, lambda p, t=Any: p(Tuple[t, ...]))
+
+    register_type(collections.deque, lambda p, t=Any: ListBasedDeque(p(List[t])))  # type: ignore
+
+    register_type(collections.abc.Iterable, lambda p, t=Any: p(Tuple[t, ...]))
+    register_type(collections.abc.Iterator, lambda p, t=Any: iter(p(Iterable[t])))  # type: ignore
+
+    register_type(collections.abc.MutableSequence, lambda p, t=Any: p(List[t]))  # type: ignore
+    register_type(collections.abc.Reversible, lambda p, t=Any: p(Tuple[t, ...]))
+    register_type(collections.abc.Sequence, lambda p, t=Any: p(Tuple[t, ...]))
+    register_type(collections.abc.Sized, lambda p, t=Any: p(Tuple[t, ...]))
+
+    register_type(collections.abc.MutableSet, lambda p, t=Any: p(Set[t]))  # type: ignore
+
+    if sys.version_info < (3, 14):
+        register_type(collections.abc.ByteString, lambda p: p(bytes))
+    if sys.version_info >= (3, 12):
+        register_type(collections.abc.Buffer, lambda p: p(bytes))
+    register_type(collections.abc.Hashable, lambda p: p(int))

crosshair/libimpl/collectionslib_ch_test.py

@@ -0,0 +1,252 @@
+import sys
+from typing import DefaultDict, Deque, Optional, Sequence
+
+import pytest  # type: ignore
+
+from crosshair.core_and_libs import MessageType, analyze_function, run_checkables
+from crosshair.options import AnalysisOptionSet
+from crosshair.test_util import ResultComparison, compare_results
+
+# deque
+
+
+def check_deque_append(queue: Deque[int], item: int):
+    """post: _"""
+
+    def checker(q, i):
+        q.append(i)
+        return q
+
+    return compare_results(checker, queue, item)
+
+
+def check_deque_appendleft(queue: Deque[int], item: int):
+    """post: _"""
+
+    def checker(q, i):
+        q.appendleft(i)
+        return q
+
+    return compare_results(checker, queue, item)
+
+
+def check_deque_copy(queue: Deque[int]):
+    """post: _"""
+    return compare_results(lambda d: d.copy(), queue)
+
+
+def check_deque_count(queue: Deque[int], item: int):
+    """post: _"""
+    return compare_results(lambda d, i: d.count(i), queue, item)
+
+
+def check_deque_extend(queue: Deque[int], items: Sequence[int]):
+    """post: _"""
+
+    def checker(q, i):
+        q.extend(i)
+        return q
+
+    return compare_results(checker, queue, items)
+
+
+def check_deque_extendleft(queue: Deque[int], items: Sequence[int]):
+    """post: _"""
+
+    def checker(q, i):
+        q.extendleft(i)
+        return q
+
+    return compare_results(checker, queue, items)
+
+
+def check_deque_index(
+    queue: Deque[int], item: int, start: Optional[int], end: Optional[int]
+):
+    """post: _"""
+    return compare_results(lambda q, i, s, e: q.index(i, s, e), queue, item, start, end)
+
+
+def check_deque_insert(queue: Deque[int], position: int, item: int):
+    """post: _"""
+
+    def checker(q, p, i):
+        q.insert(p, i)
+        return q
+
+    return compare_results(checker, queue, position, item)
+
+
+def check_deque_pop(queue: Deque[int]):
+    """post: _"""
+
+    def checker(q):
+        item = q.pop()
+        return (item, q)
+
+    return compare_results(checker, queue)
+
+
+def check_deque_popleft(queue: Deque[int]):
+    """post: _"""
+
+    def checker(q):
+        item = q.popleft()
+        return item
+
+    return compare_results(checker, queue)
+
+
+def check_deque_remove(queue: Deque[int], item: int):
+    """post: _"""
+
+    def checker(q, n):
+        q.remove(n)
+        return q
+
+    return compare_results(checker, queue, item)
+
+
+def check_deque_reverse(queue: Deque[int]):
+    """post: _"""
+
+    def checker(q):
+        q.reverse()
+        return q
+
+    return compare_results(checker, queue)
+
+
+def check_deque_rotate(queue: Deque[int], amount: int):
+    """post: _"""
+
+    def checker(q, n):
+        q.rotate(n)
+        return q
+
+    return compare_results(checker, queue, amount)
+
+
+def check_deque_maxlen(queue: Deque[int]):
+    return compare_results(lambda q: q.maxlen, queue)
+
+
+def check_deque_eq(queue: Deque[int]):
+    return compare_results(lambda q: q, queue)
+
+
+def check_deque_getitem(queue: Deque[int], idx: int):
+    """post: _"""
+    return compare_results(lambda q, i: q[i], queue, idx)
+
+
+def check_deque_contains(queue: Deque[int], item: int):
+    """post: _"""
+    return compare_results(lambda q, i: i in q, queue, item)
+
+
+def check_deque_add(queue: Deque[int], items: Deque[int]):
+    """post: _"""
+    return compare_results(lambda q, i: q + i, queue, items)
+
+
+def check_deque_mul(queue: Deque[int], count: int):
+    """post: _"""
+    return compare_results(lambda q, i: q * i, queue, count)
+
+
+# defaultdict
+
+
+def check_defaultdict_getitem(container: DefaultDict[int, int], key: int):
+    """post: _"""
+    return compare_results(lambda d, k: d[k], container, key)
+
+
+def check_defaultdict_delitem(container: DefaultDict[int, int], key: int):
+    """post: _"""
+
+    def checker(d, k):
+        del d[k]
+        return d
+
+    return compare_results(checker, container, key)
+
+
+def check_defaultdict_inplace_mutation(container: DefaultDict[int, int]):
+    """post: _"""
+
+    def setter(c):
+        if c:
+            c[0] &= 42
+        return c
+
+    return compare_results(setter, container)
+
+
+def check_defaultdict_iter(dictionary: DefaultDict[int, int]) -> ResultComparison:
+    """post: _"""
+    return compare_results(lambda d: list(d), dictionary)
+
+
+def check_defaultdict_clear(dictionary: DefaultDict[int, int]) -> ResultComparison:
+    """post: _"""
+
+    def checker(d):
+        d.clear()
+        return d
+
+    return compare_results(checker, dictionary)
+
+
+def check_defaultdict_pop(dictionary: DefaultDict[int, int]) -> ResultComparison:
+    """post: _"""
+
+    def checker(d):
+        x = d.pop()
+        return (x, d)
+
+    return compare_results(checker, dictionary)
+
+
+def check_defaultdict_popitem(
+    dictionary: DefaultDict[int, int], key: int
+) -> ResultComparison:
+    """post: _"""
+
+    def checker(d, k):
+        x = d.popitem(k)
+        return (x, d)
+
+    return compare_results(checker, dictionary)
+
+
+def check_defaultdict_update(
+    left: DefaultDict[int, int], right: DefaultDict[int, int]
+) -> ResultComparison:
+    """post: _"""
+
+    def checker(d1, d2):
+        d1.update(d2)
+        return d1
+
+    return compare_results(checker, left, right)
+
+
+def check_defaultdict_values(dictionary: DefaultDict[int, int]) -> ResultComparison:
+    """post: _"""
+    # TODO: value views compare false even with new views from the same dict.
+    # Ensure we match this behavior.
+    return compare_results(lambda d: list(d.values()), dictionary)
+
+
+# This is the only real test definition.
+# It runs crosshair on each of the "check" functions defined above.
+@pytest.mark.parametrize("fn_name", [fn for fn in dir() if fn.startswith("check_")])
+def test_builtin(fn_name: str) -> None:
+    opts = AnalysisOptionSet(max_iterations=7)
+    this_module = sys.modules[__name__]
+    fn = getattr(this_module, fn_name)
+    messages = run_checkables(analyze_function(fn, opts))
+    errors = [m for m in messages if m.state > MessageType.PRE_UNSAT]
+    assert errors == []