crosshair-tool 0.0.84__cp312-cp312-macosx_11_0_arm64.whl → 0.0.86__cp312-cp312-macosx_11_0_arm64.whl

crosshair/__init__.py

@@ -15,7 +15,7 @@ from crosshair.statespace import StateSpace
 from crosshair.tracers import NoTracing, ResumedTracing
 from crosshair.util import IgnoreAttempt, debug
 
-__version__ = "0.0.84"  # Do not forget to update in setup.py!
+__version__ = "0.0.86"  # Do not forget to update in setup.py!
 __author__ = "Phillip Schanely"
 __license__ = "MIT"
 __status__ = "Alpha"

crosshair/_mark_stacks.h

@@ -538,31 +538,6 @@ static const uint8_t _ch_DE_INSTRUMENT[256] = {
 #endif
 #endif
 
-static const uint8_t _ch_TRACABLE_INSTRUCTIONS[256] = {
-    // This must be manually kept in sync the the various
-    // instructions that we care about on the python side.
-    [MAP_ADD] = 1,
-    [BINARY_SUBSCR] = 1,
-    [BINARY_SLICE] = 1,
-    [CONTAINS_OP] = 1,
-    [BUILD_STRING] = 1,
-#if PY_VERSION_HEX < 0x030D0000
-    // <= 3.12
-    [FORMAT_VALUE] = 1,
-#elif PY_VERSION_HEX < 0x030E0000
-    // 3.13
-    [CALL_KW] = 1,
-    [CONVERT_VALUE] = 1,
-#endif
-    [UNARY_NOT] = 1,
-    [SET_ADD] = 1,
-    [IS_OP] = 1,
-    [BINARY_OP] = 1,
-    [CALL] = 1,
-    [CALL_FUNCTION_EX] = 1,
-};
-
-
 /* Get the underlying opcode, stripping instrumentation */
 int _ch_Py_GetBaseOpcode(PyCodeObject *code, int i)
 {

crosshair/_tracers.h

@@ -88,4 +88,6 @@ typedef struct TraceSwap {
 
 extern PyTypeObject TraceSwapType;
 
+extern const uint8_t _ch_TRACABLE_INSTRUCTIONS[256];
+
 #endif /* _COVERAGE_TRACER_H */

crosshair/_tracers_test.py

@@ -89,7 +89,10 @@ def _log_execution_stacks(fn, *a, **kw):
     return stacks
 
 
-@pytest.mark.skipif(sys.version_info < (3, 12), reason="stack depth on 3.12+")
+@pytest.mark.skipif(
+    sys.version_info < (3, 12) or sys.version_info >= (3, 14),
+    reason="stack depths only in 3.12 & 3.13",
+)
 def test_one_function_stack_depth():
     _E = (TypeError, KeyboardInterrupt)
 
@@ -100,7 +103,10 @@ def test_one_function_stack_depth():
     _log_execution_stacks(a, 4)
 
 
-@pytest.mark.skipif(sys.version_info < (3, 12), reason="stack depth on 3.12+")
+@pytest.mark.skipif(
+    sys.version_info < (3, 12) or sys.version_info >= (3, 14),
+    reason="stack depths only in 3.12 & 3.13",
+)
 def test_stack_get():
     def to_be_traced(x):
         r = 8 - x

crosshair/condition_parser.py

@@ -47,6 +47,7 @@ from crosshair.options import AnalysisKind
 from crosshair.register_contract import get_contract
 from crosshair.tracers import NoTracing
 from crosshair.util import (
+    CrossHairInternal,
     DynamicScopeVar,
     EvalFriendlyReprContext,
     IdKeyedDict,
@@ -485,6 +486,7 @@ class ConcreteConditionParser(ConditionParser):
             method = cls.__dict__.get(method_name, None)
             super_method_conditions = super_methods.get(method_name)
             if super_method_conditions is not None:
+                # Re-type the super's `self` argument to be this class:
                 revised_sig = set_first_arg_type(super_method_conditions.sig, cls)
                 super_method_conditions = replace(
                     super_method_conditions, sig=revised_sig
@@ -511,17 +513,15 @@ class ConcreteConditionParser(ConditionParser):
             final_pre = list(conditions.pre)
             final_post = list(conditions.post)
             if method_name in (
-                "__new__",  # isn't passed a concrete instance.
+                "__new__",  # a staticmethod, but not isinstance(staticmethod)
                 "__repr__",  # is itself required for reporting problems with invariants.
                 # [set/del]attr can do anything; we can't resonably enforce invariants:
                 "__setattr__",
                 "__delattr__",
+                "__replace__",  # Will raise an exception with most arbitrary **kwargs.
+                "__annotate__",  # a staticmethod, but not isinstance(staticmethod)
             ):
                 pass
-            elif method_name == "__replace__":
-                # TODO: remove this case when fixed in 3.13
-                # see https://github.com/python/cpython/issues/114198
-                pass
             elif method_name == "__del__":
                 final_pre.extend(inv)
             elif method_name == "__init__":

crosshair/condition_parser_test.py

@@ -140,7 +140,7 @@ class TestPep316Parser:
             "self.x >= 0",
             "self.y >= 0",
         }
-        assert set(class_conditions.methods.keys()) == {"isready", "__init__"}
+        assert {"isready", "__init__"} <= set(class_conditions.methods.keys())
         method = class_conditions.methods["isready"]
         assert set([c.expr_source for c in method.pre]) == {
             "self.x >= 0",

crosshair/copyext.py

@@ -1,4 +1,9 @@
-from copy import _deepcopy_atomic  # type: ignore
+import sys
+
+if sys.version_info >= (3, 14):
+    from copy import _atomic_types
+else:
+    from copy import _deepcopy_atomic  # type: ignore
 from copy import _deepcopy_dict  # type: ignore
 from copy import _deepcopy_dispatch  # type: ignore
 from copy import _deepcopy_list  # type: ignore
@@ -9,7 +14,7 @@ from copy import Error
 from copyreg import dispatch_table  # type: ignore
 from enum import Enum
 from types import MappingProxyType
-from typing import Any, Dict, Tuple
+from typing import Any, Callable, Dict, Tuple
 
 from crosshair.tracers import ResumedTracing
 from crosshair.util import (
@@ -85,17 +90,28 @@ def deepcopyext(obj: object, mode: CopyMode, memo: Dict) -> Any:
     return cpy
 
 
+if sys.version_info >= (3, 14):
+
+    def lookup_dispatch(cls: type) -> Callable:
+        if cls in _atomic_types:
+            return lambda obj, memo: obj
+        return _deepcopy_dispatch.get(cls)
+
+else:
+
+    def lookup_dispatch(cls: type) -> Callable:
+        return _deepcopy_dispatch.get(cls)
+
+
 def _deepconstruct(obj: object, mode: CopyMode, memo: Dict):
     cls = type(obj)
 
     def subdeepcopy(obj: object, memo: Dict):
         return deepcopyext(obj, mode, memo)
 
-    if cls in _deepcopy_dispatch:
-        creator = _deepcopy_dispatch[cls]
-        if creator is _deepcopy_atomic:
-            return obj
-        elif creator in (_deepcopy_dict, _deepcopy_list, _deepcopy_tuple):
+    creator = lookup_dispatch(cls)
+    if creator is not None:
+        if creator in (_deepcopy_dict, _deepcopy_list, _deepcopy_tuple):
             return creator(obj, memo, deepcopy=subdeepcopy)
         else:
             # TODO: We loose subdeepcopy in this case - won't

crosshair/copyext_test.py

@@ -7,7 +7,7 @@ import pytest
 from crosshair.copyext import CopyMode, deepcopyext
 from crosshair.core_and_libs import proxy_for_type, standalone_statespace
 from crosshair.libimpl.builtinslib import SymbolicInt
-from crosshair.tracers import NoTracing, ResumedTracing
+from crosshair.tracers import NoTracing
 
 
 def test_deepcopyext_best_effort():
@@ -33,6 +33,16 @@ def test_deepcopyext_symbolic_set():
             deepcopyext(s, CopyMode.REALIZE, {})
 
 
+def test_deepcopyext_realize_simple(space):
+    x = SymbolicInt("x")
+    input = (x,)
+    output = deepcopyext(input, CopyMode.REALIZE, {})
+    assert input is not output
+    assert input[0] is not output[0]
+    assert type(input[0]) is SymbolicInt
+    assert type(output[0]) is int
+
+
 def test_deepcopyext_realize(space):
     x = SymbolicInt("x")
     lock = RLock()

crosshair/dynamic_typing.py

@@ -4,7 +4,7 @@ from inspect import Parameter, Signature
 from itertools import zip_longest
 from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple, Type
 
-import typing_inspect
+import typing_inspect  # type: ignore
 
 from crosshair.util import debug  # type: ignore
 

crosshair/fnutil_test.py

@@ -26,7 +26,10 @@ def test_fn_globals_on_builtin() -> None:
 
 def test_resolve_signature_invalid_annotations() -> None:
     sig = resolve_signature(with_invalid_type_annotation)
-    assert sig == "name 'TypeThatIsNotDefined' is not defined"
+    if sys.version_info >= (3, 14):
+        assert sig == "TypeThatIsNotDefined"
+    else:
+        assert sig == "name 'TypeThatIsNotDefined' is not defined"
 
 
 @pytest.mark.skipif(

crosshair/libimpl/arraylib.py

@@ -30,19 +30,6 @@ INT_TYPE_BOUNDS: Dict[str, Tuple[int, int]] = {
 INT_TYPE_SIZE = {c: array(c).itemsize for c in INT_TYPE_BOUNDS.keys()}
 
 
-if sys.version_info >= (3, 12):
-    from collections.abc import Buffer
-
-    def is_bytes_like(obj: object) -> bool:
-        return isinstance(obj, Buffer)
-
-else:
-    from collections.abc import ByteString
-
-    def is_bytes_like(obj: object) -> bool:
-        return isinstance(obj, (ByteString, array))
-
-
 def pick_code(space: StateSpace) -> Tuple[str, int, int]:
     last_idx = len(INT_TYPE_BOUNDS) - 1
     for (idx, (code, rng)) in enumerate(INT_TYPE_BOUNDS.items()):

crosshair/libimpl/builtinslib.py

@@ -17,7 +17,7 @@ from dataclasses import dataclass
 from itertools import zip_longest
 from math import inf, isfinite, isinf, isnan, nan
 from numbers import Integral, Number, Real
-from sys import maxunicode
+from sys import maxunicode, version_info
 from typing import (
     Any,
     BinaryIO,
@@ -58,6 +58,8 @@ try:
 except ImportError:
     from z3 import FfpEQ as fpEQ
 
+import sys
+
 from crosshair.abcstring import AbcString
 from crosshair.core import (
     SymbolicFactory,
@@ -116,6 +118,7 @@ from crosshair.util import (
     assert_tracing,
     ch_stack,
     debug,
+    is_bytes_like,
     is_hashable,
     is_iterable,
     memo,
@@ -399,6 +402,10 @@ def crosshair_types_for_python_type(
     return _PYTYPE_TO_WRAPPER_TYPE.get(origin, ())
 
 
+def python_types_using_atomic_symbolics() -> Iterable[Type[AtomicSymbolicValue]]:
+    return _PYTYPE_TO_WRAPPER_TYPE.keys()
+
+
 class ModelingDirector:
     def __init__(self, *a) -> None:
         # Maps python type to the symbolic type we've chosen to represent it (on this iteration)
@@ -1213,10 +1220,11 @@ class SymbolicInt(SymbolicIntable, AtomicSymbolicValue):
         cur_divisor = 10
         while True:
             leftover = self // cur_divisor
-            if leftover == 0:
+            if leftover != 0:
+                codepoints.append(48 + (leftover % 10))
+                cur_divisor *= 10
+            else:
                 break
-            codepoints.append(48 + (leftover % 10))
-            cur_divisor *= 10
         with NoTracing():
             codepoints.reverse()
             return LazyIntSymbolicStr(codepoints)
@@ -1316,7 +1324,7 @@ class SymbolicInt(SymbolicIntable, AtomicSymbolicValue):
                 z3.If(val < 128, 7, 8)))))))))
             # fmt: on
 
-    if sys.version_info >= (3, 12):
+    if version_info >= (3, 12):
 
         def is_integer(self):
             return True
@@ -2934,7 +2942,7 @@ class AnySymbolicStr(AbcString):
     def capitalize(self):
         if self.__len__() == 0:
             return ""
-        if sys.version_info >= (3, 8):
+        if version_info >= (3, 8):
             firstchar = self[0].title()
         else:
             firstchar = self[0].upper()
@@ -3172,7 +3180,7 @@ class AnySymbolicStr(AbcString):
         return ""
 
     def splitlines(self, keepends=False):
-        if sys.version_info < (3, 12):
+        if version_info < (3, 12):
             if not isinstance(keepends, int):
                 raise TypeError
         mylen = self.__len__()
@@ -3438,6 +3446,7 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
                 SliceView,
                 SequenceConcatenation,
                 list,  # TODO: are we sharing mutable state here?
+                tuple,
             ),
         ):
             self._codepoints = smtvar
@@ -3483,10 +3492,6 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
                 otherpoints = [ord(ch) for ch in other]
                 with ResumedTracing():
                     return mypoints.__eq__(otherpoints)
-            elif isinstance(other, SeqBasedSymbolicStr):
-                with ResumedTracing():
-                    otherpoints = [ord(ch) for ch in other]
-                    return mypoints.__eq__(otherpoints)
             else:
                 return NotImplemented
 
@@ -3655,257 +3660,6 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
         return self._find(substr, start, end, from_right=True)
 
 
-class SeqBasedSymbolicStr(AtomicSymbolicValue, SymbolicSequence, AnySymbolicStr):
-    def __init__(self, smtvar: Union[str, z3.ExprRef], typ: Type = str):
-        assert typ == str
-        SymbolicValue.__init__(self, smtvar, typ)
-        self.item_pytype = str
-        if isinstance(smtvar, str):
-            # Constrain fresh strings to valid codepoints
-            space = context_statespace()
-            idxvar = z3.Int("idxvar" + space.uniq())
-            z3seq = self.var
-            space.add(
-                z3.ForAll(
-                    [idxvar], z3.And(0 <= z3seq[idxvar], z3seq[idxvar] <= maxunicode)
-                )
-            )
-
-    @classmethod
-    def _ch_smt_sort(cls) -> z3.SortRef:
-        return z3.SeqSort(z3.IntSort())
-
-    @classmethod
-    def _pytype(cls) -> Type:
-        return str
-
-    @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
-        if isinstance(literal, str):
-            if len(literal) <= 1:
-                if len(literal) == 0:
-                    return z3.Empty(z3.SeqSort(z3.IntSort()))
-                return z3.Unit(z3IntVal(ord(literal)))
-            return z3.Concat([z3.Unit(z3IntVal(ord(ch))) for ch in literal])
-        return None
-
-    def __ch_realize__(self) -> object:
-        codepoints = context_statespace().find_model_value(self.var)
-        return "".join(chr(x) for x in codepoints)
-
-    def __copy__(self):
-        return SeqBasedSymbolicStr(self.var)
-
-    def __hash__(self):
-        return hash(self.__str__())
-
-    @staticmethod
-    def _concat_strings(
-        a: Union[str, "SeqBasedSymbolicStr"], b: Union[str, "SeqBasedSymbolicStr"]
-    ) -> Union[str, "SeqBasedSymbolicStr"]:
-        assert not is_tracing()
-        # Assumes at least one argument is symbolic and not tracing
-        if isinstance(a, SeqBasedSymbolicStr) and isinstance(b, SeqBasedSymbolicStr):
-            return SeqBasedSymbolicStr(a.var + b.var)
-        elif isinstance(a, str) and isinstance(b, SeqBasedSymbolicStr):
-            return SeqBasedSymbolicStr(
-                SeqBasedSymbolicStr._coerce_to_smt_sort(a) + b.var
-            )
-        else:
-            assert isinstance(a, SeqBasedSymbolicStr)
-            assert isinstance(b, str)
-            return SeqBasedSymbolicStr(
-                a.var + SeqBasedSymbolicStr._coerce_to_smt_sort(b)
-            )
-
-    def __add__(self, other):
-        with NoTracing():
-            if isinstance(other, (SeqBasedSymbolicStr, str)):
-                return SeqBasedSymbolicStr._concat_strings(self, other)
-            if isinstance(other, AnySymbolicStr):
-                return NotImplemented
-            raise TypeError
-
-    def __radd__(self, other):
-        with NoTracing():
-            if isinstance(other, (SeqBasedSymbolicStr, str)):
-                return SeqBasedSymbolicStr._concat_strings(other, self)
-            if isinstance(other, AnySymbolicStr):
-                return NotImplemented
-            raise TypeError
-
-    def __mul__(self, other):
-        if isinstance(other, Integral):
-            if other <= 1:
-                return self if other == 1 else ""
-            # Note that in SymbolicInt, we attempt string multiplication via regex.
-            # Z3 cannot do much with a symbolic regex, so we case-split on
-            # the repetition count.
-            return SeqBasedSymbolicStr(z3.Concat(*[self.var for _ in range(other)]))
-        return NotImplemented
-
-    __rmul__ = __mul__
-
-    def __mod__(self, other):
-        return self.__str__() % realize(other)
-
-    def __contains__(self, other):
-        with NoTracing():
-            forced = force_to_smt_sort(other, SeqBasedSymbolicStr)
-            return SymbolicBool(z3.Contains(self.var, forced))
-
-    def __getitem__(self, i: Union[int, slice]):
-        with NoTracing():
-            idx_or_pair = process_slice_vs_symbolic_len(
-                context_statespace(), i, z3.Length(self.var)
-            )
-            if isinstance(idx_or_pair, tuple):
-                (start, stop) = idx_or_pair
-                smt_result = z3.Extract(self.var, start, stop - start)
-            else:
-                smt_result = z3.Unit(self.var[idx_or_pair])
-            return SeqBasedSymbolicStr(smt_result)
-
-    def endswith(self, substr):
-        with NoTracing():
-            smt_substr = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-            return SymbolicBool(z3.SuffixOf(smt_substr, self.var))
-
-    def find(self, substr, start=None, end=None):
-        if not isinstance(substr, str):
-            raise TypeError
-        with NoTracing():
-            space = context_statespace()
-            smt_my_len = z3.Length(self.var)
-            if start is None and end is None:
-                smt_start = z3IntVal(0)
-                smt_end = smt_my_len
-                smt_str = self.var
-                if len(substr) == 0:
-                    return 0
-            else:
-                (smt_start, smt_end) = flip_slice_vs_symbolic_len(
-                    space, slice(start, end, None), smt_my_len
-                )
-                if len(substr) == 0:
-                    # Add oddity of CPython. We can find the empty string when over-slicing
-                    # off the left side of the string, but not off the right:
-                    # ''.find('', 3, 4) == -1
-                    # ''.find('', -4, -3) == 0
-                    if space.smt_fork(smt_start > smt_my_len):
-                        return -1
-                    elif space.smt_fork(smt_start > 0):
-                        return SymbolicInt(smt_start)
-                    else:
-                        return 0
-                (smt_start, smt_end) = clip_range_to_symbolic_len(
-                    space, smt_start, smt_end, smt_my_len
-                )
-                smt_str = z3.SubString(self.var, smt_start, smt_end - smt_start)
-
-            smt_sub = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-            if space.smt_fork(z3.Contains(smt_str, smt_sub)):
-                return SymbolicInt(z3.IndexOf(smt_str, smt_sub, 0) + smt_start)
-            else:
-                return -1
-
-    def partition(self, sep: str):
-        if not isinstance(sep, str):
-            raise TypeError
-        if len(sep) == 0:
-            raise ValueError
-        with NoTracing():
-            space = context_statespace()
-            smt_str = self.var
-            smt_sep = force_to_smt_sort(sep, SeqBasedSymbolicStr)
-            if space.smt_fork(z3.Contains(smt_str, smt_sep)):
-                uniq = space.uniq()
-                # Divide my contents into 4 concatenated parts:
-                prefix = SeqBasedSymbolicStr(f"prefix{uniq}")
-                match1 = SeqBasedSymbolicStr(
-                    f"match1{uniq}"
-                )  # the first character of the match
-                match_tail = SeqBasedSymbolicStr(f"match_tail{uniq}")
-                suffix = SeqBasedSymbolicStr(f"suffix{uniq}")
-                space.add(z3.Length(match1.var) == 1)
-                space.add(smt_sep == z3.Concat(match1.var, match_tail.var))
-                space.add(smt_str == z3.Concat(prefix.var, smt_sep, suffix.var))
-                space.add(
-                    z3.Not(z3.Contains(z3.Concat(match_tail.var, suffix.var), smt_sep))
-                )
-                return (prefix, sep, suffix)
-            else:
-                return (self, "", "")
-
-    def rfind(self, substr, start=None, end=None) -> Union[int, SymbolicInt]:
-        if not isinstance(substr, str):
-            raise TypeError
-        with NoTracing():
-            space = context_statespace()
-            smt_my_len = z3.Length(self.var)
-            if start is None and end is None:
-                smt_start = z3IntVal(0)
-                smt_end = smt_my_len
-                smt_str = self.var
-                if len(substr) == 0:
-                    return SymbolicInt(smt_my_len)
-            else:
-                (smt_start, smt_end) = flip_slice_vs_symbolic_len(
-                    space, slice(start, end, None), smt_my_len
-                )
-                if len(substr) == 0:
-                    # Add oddity of CPython. We can find the empty string when over-slicing
-                    # off the left side of the string, but not off the right:
-                    # ''.find('', 3, 4) == -1
-                    # ''.find('', -4, -3) == 0
-                    if space.smt_fork(smt_start > smt_my_len):
-                        return -1
-                    elif space.smt_fork(smt_end < 0):
-                        return 0
-                    elif space.smt_fork(smt_end < smt_my_len):
-                        return SymbolicInt(smt_end)
-                    else:
-                        return SymbolicInt(smt_my_len)
-                (smt_start, smt_end) = clip_range_to_symbolic_len(
-                    space, smt_start, smt_end, smt_my_len
-                )
-                smt_str = z3.SubString(self.var, smt_start, smt_end - smt_start)
-            smt_sub = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-            if space.smt_fork(z3.Contains(smt_str, smt_sub)):
-                uniq = space.uniq()
-                # Divide my contents into 4 concatenated parts:
-                prefix = SeqBasedSymbolicStr(f"prefix{uniq}")
-                match1 = SeqBasedSymbolicStr(f"match1{uniq}")
-                match_tail = SeqBasedSymbolicStr(f"match_tail{uniq}")
-                suffix = SeqBasedSymbolicStr(f"suffix{uniq}")
-                space.add(z3.Length(match1.var) == 1)
-                space.add(smt_sub == z3.Concat(match1.var, match_tail.var))
-                space.add(smt_str == z3.Concat(prefix.var, smt_sub, suffix.var))
-                space.add(
-                    z3.Not(z3.Contains(z3.Concat(match_tail.var, suffix.var), smt_sub))
-                )
-                return SymbolicInt(smt_start + z3.Length(prefix.var))
-            else:
-                return -1
-
-    def rpartition(self, sep: str):
-        result = self.rsplit(sep, maxsplit=1)
-        if len(result) == 1:
-            return ("", "", self)
-        elif len(result) == 2:
-            return (result[0], sep, result[1])
-
-    def startswith(self, substr, start=None, end=None):
-        if isinstance(substr, tuple):
-            return any(self.startswith(s, start, end) for s in substr)
-        smt_substr = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-        if start is not None or end is not None:
-            # TODO: "".startswith("", 1) should be False, not True
-            return self[start:end].startswith(substr)
-        with NoTracing():
-            return SymbolicBool(z3.PrefixOf(smt_substr, self.var))
-
-
 def buffer_to_byte_seq(obj: object) -> Optional[Sequence[int]]:
     if isinstance(obj, (bytes, bytearray)):
         return list(obj)
@@ -3975,7 +3729,7 @@ class BytesLike(Buffer, AbcString, CrossHairValue):
             return False
         return list(self) == list(other)
 
-    if sys.version_info >= (3, 12):
+    if version_info >= (3, 12):
 
         def __buffer__(self, flags: int):
             with NoTracing():
@@ -4135,7 +3889,10 @@ class SymbolicBytes(BytesLike):
         accumulated = []
         high = None
         if not isinstance(hexstr, str):
-            raise TypeError
+            if is_bytes_like(hexstr) and version_info >= (3, 14):
+                hexstr = LazyIntSymbolicStr(tuple(hexstr))
+            else:
+                raise TypeError
         for idx, ch in enumerate(hexstr):
             if not ch.isascii():
                 raise ValueError(
@@ -4814,11 +4571,6 @@ def _ord(c: str) -> int:
     with NoTracing():
         if isinstance(c, LazyIntSymbolicStr):
             return c._codepoints[0]
-        elif isinstance(c, SeqBasedSymbolicStr):
-            space = context_statespace()
-            ret = SymbolicInt("ord" + space.uniq())
-            space.add(c.var == z3.Unit(ret.var))
-            return ret
     return ord(realize(c))
 
 
@@ -4894,7 +4646,7 @@ def _int_from_bytes(
 ) -> int:
     if byteorder is _MISSING:
         # byteorder defaults to "big" as of 3.11
-        if sys.version_info >= (3, 11):
+        if version_info >= (3, 11):
             byteorder = "big"
         else:
             raise TypeError
@@ -5108,7 +4860,7 @@ def make_registrations():
 
     register_type(Union, make_union_choice)
 
-    if sys.version_info >= (3, 8):
+    if version_info >= (3, 8):
         from typing import Final
 
         register_type(Final, lambda p, t: p(t))
@@ -5266,7 +5018,7 @@ def make_registrations():
         "upper",
         "zfill",
     ]
-    if sys.version_info >= (3, 9):
+    if version_info >= (3, 9):
         names_to_str_patch.append("removeprefix")
         names_to_str_patch.append("removesuffix")
     for name in names_to_str_patch:
@@ -5322,12 +5074,12 @@ def make_registrations():
     # Patches on int
     register_patch(int.__repr__, with_checked_self(int, "__repr__"))
     register_patch(int.as_integer_ratio, with_checked_self(int, "as_integer_ratio"))
-    if sys.version_info >= (3, 10):
+    if version_info >= (3, 10):
         register_patch(int.bit_count, with_checked_self(int, "bit_count"))
     register_patch(int.bit_length, with_checked_self(int, "bit_length"))
     register_patch(int.conjugate, with_checked_self(int, "conjugate"))
     register_patch(int.from_bytes, _int_from_bytes)
-    if sys.version_info >= (3, 12):
+    if version_info >= (3, 12):
         register_patch(int.is_integer, with_checked_self(int, "is_integer"))
     register_patch(int.to_bytes, with_checked_self(int, "to_bytes"))
 

crosshair/libimpl/builtinslib_test.py

@@ -2117,7 +2117,7 @@ def test_dict___bool___ok() -> None:
     check_states(f, CONFIRMED)
 
 
-def test_dict___iter__() -> None:
+def test_dict___iter___fail() -> None:
     def f(a: Dict[int, str]) -> List[int]:
         """
         post[a]: 5 in _