crosshair-tool 0.0.85__cp313-cp313-macosx_10_13_x86_64.whl → 0.0.86__cp313-cp313-macosx_10_13_x86_64.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.85"  # 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/libimpl/builtinslib.py

@@ -402,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)
@@ -3488,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
 
@@ -3660,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)
@@ -4822,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))
 
 

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 _

crosshair/libimpl/typeslib_test.py

@@ -30,6 +30,7 @@ def test_mappingproxy_deep_realize(space):
     assert type(copy) is MappingProxyType
     with ResumedTracing():
         val_from_orig = orig[key]
-        val_from_copy = copy[key]
+        realized_key = deep_realize(key)
+    val_from_copy = copy[realized_key]
     assert type(val_from_orig) is SymbolicInt
     assert type(val_from_copy) is int

crosshair/opcode_intercept.py

@@ -1,10 +1,11 @@
 import dis
 import sys
 import weakref
+from collections import defaultdict
 from collections.abc import MutableMapping, Set
 from sys import version_info
 from types import CodeType, FrameType
-from typing import Callable
+from typing import Any, Callable, Iterable, Mapping, Tuple, Union
 
 from crosshair.core import (
     ATOMIC_IMMUTABLE_TYPES,
@@ -13,20 +14,29 @@ from crosshair.core import (
 )
 from crosshair.libimpl.builtinslib import (
     AnySymbolicStr,
+    AtomicSymbolicValue,
+    ModelingDirector,
     SymbolicBool,
     SymbolicInt,
     SymbolicList,
+    python_types_using_atomic_symbolics,
 )
 from crosshair.simplestructs import LinearSet, ShellMutableSet, SimpleDict, SliceView
 from crosshair.statespace import context_statespace
 from crosshair.tracers import (
     COMPOSITE_TRACER,
     NoTracing,
+    ResumedTracing,
     TracingModule,
     frame_stack_read,
     frame_stack_write,
 )
-from crosshair.util import CROSSHAIR_EXTRA_ASSERTS, CrossHairInternal, CrossHairValue
+from crosshair.util import (
+    CROSSHAIR_EXTRA_ASSERTS,
+    CrossHairInternal,
+    CrossHairValue,
+    debug,
+)
 from crosshair.z3util import z3Not, z3Or
 
 BINARY_SUBSCR = dis.opmap.get("BINARY_SUBSCR", 256)
@@ -60,13 +70,100 @@ _DEEPLY_CONCRETE_KEY_TYPES = (
 )
 
 
+class MultiSubscriptableContainer:
+    """Used for indexing a symbolic (non-slice) key into a concrete container"""
+
+    def __init__(self, container: Union[list, tuple, dict]):
+        self.container = container
+
+    def __getitem__(self, key: AtomicSymbolicValue) -> object:
+        with NoTracing():
+            space = context_statespace()
+            container = self.container
+            if isinstance(container, Mapping):
+                kv_pairs: Iterable[Tuple[Any, Any]] = container.items()
+            else:
+                in_bounds = space.smt_fork(
+                    z3Or(-len(container) <= key.var, key.var < len(container)),
+                    desc=f"index_in_bounds",
+                    probability_true=0.9,
+                )
+                if not in_bounds:
+                    raise IndexError
+                kv_pairs = enumerate(container)
+
+            values_by_type = defaultdict(list)
+            values_by_id = {}
+            keys_by_value_id = defaultdict(list)
+            symbolic_for_pytype = space.extra(ModelingDirector).choose
+            for cur_key, cur_value in kv_pairs:
+                if (
+                    isinstance(cur_value, AtomicSymbolicValue)
+                    or type(cur_value) in python_types_using_atomic_symbolics()
+                ):
+                    pytype = (
+                        cur_value._pytype()
+                        if isinstance(cur_value, AtomicSymbolicValue)
+                        else type(cur_value)
+                    )
+                    # Some types like real-based float and symbolic types don't cover all values:
+                    if (
+                        symbolic_for_pytype(pytype)._smt_promote_literal(cur_value)
+                        is not None
+                    ):
+                        values_by_type[pytype].append((cur_key, cur_value))
+                        continue
+                # No symbolics cover this value, but we might still find repeated values:
+                values_by_id[id(cur_value)] = cur_value
+                keys_by_value_id[id(cur_value)].append(cur_key)
+            for value_type, cur_pairs in values_by_type.items():
+                hypothetical_result = symbolic_for_pytype(value_type)(
+                    "item_at_" + space.uniq(), value_type
+                )
+                with ResumedTracing():
+                    condition_pairs = []
+                    for cur_key, cur_val in cur_pairs:
+                        keys_equal = key == cur_key
+                        values_equal = hypothetical_result == cur_val
+                        with NoTracing():
+                            if isinstance(keys_equal, SymbolicBool):
+                                condition_pairs.append((keys_equal, values_equal))
+                            elif keys_equal is False:
+                                pass
+                            else:
+                                # (because the key must be symbolic, we don't ever expect raw True)
+                                raise CrossHairInternal(
+                                    f"key comparison type: {type(keys_equal)} {keys_equal}"
+                                )
+                    if any(keys_equal for keys_equal, _ in condition_pairs):
+                        space.add(any([all(pair) for pair in condition_pairs]))
+                        return hypothetical_result
+
+            for (value_id, value), probability_true in with_uniform_probabilities(
+                values_by_id.items()
+            ):
+                keys_for_value = keys_by_value_id[value_id]
+                with ResumedTracing():
+                    is_match = any([key == k for k in keys_for_value])
+                if isinstance(is_match, SymbolicBool):
+                    if space.smt_fork(
+                        is_match.var,
+                        probability_true=probability_true,
+                    ):
+                        return value
+                elif is_match:
+                    return value
+
+            if type(container) is dict:
+                raise KeyError  # ( f"Key {key} not found in dict")
+            else:
+                raise IndexError  # (f"Index {key} out of range for list/tuple of length {len(container)}")
+
+
 class SymbolicSubscriptInterceptor(TracingModule):
     opcodes_wanted = frozenset([BINARY_SUBSCR, BINARY_OP])
 
     def trace_op(self, frame, codeobj, codenum):
-        # Note that because this is called from inside a Python trace handler, tracing
-        # is automatically disabled, so there's no need for a `with NoTracing():` guard.
-
         if codenum == BINARY_OP:
             oparg = frame_op_arg(frame)
             if oparg != 26:  # subscript operator, NB_SUBSCR
@@ -78,7 +175,14 @@ class SymbolicSubscriptInterceptor(TracingModule):
         # If we got this far, the index is likely symbolic (or perhaps a slice object)
         container = frame_stack_read(frame, -2)
         container_type = type(container)
-        if container_type is dict:
+        if isinstance(key, AtomicSymbolicValue) and type(container) in (
+            tuple,
+            list,
+            dict,
+        ):
+            wrapped_container = MultiSubscriptableContainer(container)
+            frame_stack_write(frame, -2, wrapped_container)
+        elif container_type is dict:
             # SimpleDict won't hash the keys it's given!
             wrapped_dict = SimpleDict(list(container.items()))
             frame_stack_write(frame, -2, wrapped_dict)
@@ -90,41 +194,6 @@ class SymbolicSubscriptInterceptor(TracingModule):
             if isinstance(start, SymbolicInt) or isinstance(stop, SymbolicInt):
                 view_wrapper = SliceView(container, 0, len(container))
                 frame_stack_write(frame, -2, SymbolicList(view_wrapper))
-        elif container_type is list or container_type is tuple:
-            if not isinstance(key, SymbolicInt):
-                return
-            # We can't stay symbolic with a concrete list and symbolic numeric index.
-            # But we can make the choice evenly and combine duplicate values, if any.
-
-            space = context_statespace()
-            in_bounds = space.smt_fork(
-                z3Or(-len(container) <= key.var, key.var < len(container)),
-                desc=f"index_in_bounds",
-                probability_true=0.9,
-            )
-            if not in_bounds:
-                return
-            # TODO: `container` should be the same (per path node) on every run;
-            # it would be great to cache this computation somehow.
-            indices = {}
-            for idx, value in enumerate(container):
-                value_id = id(value)
-                if value_id in indices:
-                    indices[value_id].append(idx)
-                else:
-                    indices[value_id] = [idx]
-            for value_id, probability_true in with_uniform_probabilities(
-                indices.keys()
-            ):
-                indices_with_value = indices[value_id]
-                if space.smt_fork(
-                    z3Or(*[key.var == i for i in indices_with_value]),
-                    desc=f"index_to_{'_or_'.join(map(str, indices_with_value))}",
-                    probability_true=probability_true,
-                ):
-                    # avoids realization of `key` in case `container` has duplicates
-                    frame_stack_write(frame, -1, indices_with_value[0])
-                    break
 
 
 class SymbolicSliceInterceptor(TracingModule):

crosshair/opcode_intercept_test.py

@@ -1,10 +1,19 @@
+import math
 import sys
+from abc import ABCMeta
 from typing import List, Set
 
 import pytest
 
 from crosshair.core_and_libs import NoTracing, proxy_for_type, standalone_statespace
-from crosshair.statespace import POST_FAIL, MessageType
+from crosshair.libimpl.builtinslib import (
+    ModelingDirector,
+    RealBasedSymbolicFloat,
+    SymbolicBool,
+    SymbolicInt,
+    SymbolicType,
+)
+from crosshair.statespace import POST_FAIL
 from crosshair.test_util import check_states
 from crosshair.tracers import ResumedTracing
 from crosshair.z3util import z3And
@@ -23,7 +32,73 @@ def test_dict_index():
     check_states(numstr, POST_FAIL)
 
 
-def test_concrete_list_with_symbolic_index_deduplicates_values(space):
+def test_dict_index_without_realization(space):
+    class WithMeta(metaclass=ABCMeta):
+        pass
+
+    space.extra(ModelingDirector).global_representations[float] = RealBasedSymbolicFloat
+    a = {
+        -1: WithMeta,
+        #   ^ tests regression: isinstance(WithMeta(), type) but type(WithMeta) != type
+        0: list,
+        1.0: 10.0,
+        2: 20,
+        3: 30,
+        4: 40,
+        ("complex", "key"): 50,
+        6: math.inf,
+        7: math.inf,
+    }
+    int_key = proxy_for_type(int, "int_key")
+    int_key2 = proxy_for_type(int, "int_key2")
+    int_key3 = proxy_for_type(int, "int_key3")
+    float_key = RealBasedSymbolicFloat("float_key")
+    float_key2 = RealBasedSymbolicFloat("float_key2")
+    with ResumedTracing():
+        # Try some concrete values out first:
+        assert a[("complex", "key")] == 50
+        assert a[6] == float("inf")
+        try:
+            a[42]
+            assert False, "Expected KeyError for missing key 42"
+        except KeyError:
+            pass
+
+        space.add(2 <= int_key)
+        space.add(int_key <= 4)
+        int_result = a[int_key]
+        assert space.is_possible(int_result == 20)
+        assert space.is_possible(int_result == 40)
+        assert not space.is_possible(int_result == 10)
+        space.add(float_key == 1.0)
+        float_result = a[float_key]
+        assert space.is_possible(float_result == 10.0)
+        assert not space.is_possible(float_result == 42.0)
+        space.add(float_key2 == 2.0)
+        float_result2 = a[float_key2]
+        assert space.is_possible(float_result2 == 20)
+        space.add(int_key2 == 0)
+        int_result2 = a[int_key2]
+        assert int_result2 == list
+        space.add(any([int_key3 == 6, int_key3 == 7]))
+        inf_result = a[int_key3]
+        assert inf_result is math.inf
+    assert isinstance(int_result, SymbolicInt)
+    assert isinstance(float_result, RealBasedSymbolicFloat)
+    assert isinstance(float_result2, SymbolicInt)
+    assert isinstance(int_result2, SymbolicType)
+
+
+def test_dict_symbolic_index_miss(space):
+    a = {6: 60, 7: 70}
+    x = proxy_for_type(int, "x")
+    with ResumedTracing():
+        space.add(x <= 4)
+        with pytest.raises(KeyError):
+            result = a[x]
+
+
+def test_concrete_list_with_symbolic_index_simple(space):
     haystack = [False] * 13 + [True] + [False] * 11
 
     idx = proxy_for_type(int, "idx")
@@ -31,8 +106,12 @@ def test_concrete_list_with_symbolic_index_deduplicates_values(space):
         space.add(0 <= idx)
         space.add(idx < len(haystack))
         ret = haystack[idx]
-        assert ret
-        assert not space.is_possible(idx != 13)
+    assert isinstance(ret, SymbolicBool)
+    with ResumedTracing():
+        assert space.is_possible(idx == 13)
+        assert space.is_possible(idx == 12)
+        space.add(ret)
+        assert not space.is_possible(idx == 12)
 
 
 def test_concrete_list_with_symbolic_index_unhashable_values(space):
@@ -204,5 +283,6 @@ def test_identity_operator_does_not_realize_on_differing_types():
             b1 = proxy_for_type(bool, "b1")
             choices_made_at_start = len(space.choices_made)
         space.add(b1)
-        _ = b1 is 42  # noqa: F632
+        fourty_two = 42  # assignment just to avoid lint errors
+        b1 is fourty_two
         assert len(space.choices_made) == choices_made_at_start

crosshair/statespace.py

@@ -743,11 +743,13 @@ class StateSpace:
         model_check_timeout: float,
         search_root: RootNode,
     ):
-        smt_timeout = model_check_timeout * 1000 + 1
         smt_tactic = z3.Tactic("smt")
-        if smt_timeout < 1 << 63:
-            smt_tactic = z3.TryFor(smt_tactic, int(smt_timeout))
         self.solver = smt_tactic.solver()
+        if model_check_timeout < 1 << 63:
+            self.smt_timeout: Optional[int] = int(model_check_timeout * 1000 + 1)
+            self.solver.set(timeout=self.smt_timeout)
+        else:
+            self.smt_timeout = None
         self.solver.set(mbqi=True)
         # turn off every randomization thing we can think of:
         self.solver.set("random-seed", 42)
@@ -1097,7 +1099,10 @@ class StateSpace:
             else:
                 # Give ourselves a time extension for deferred assumptions and
                 # (likely) counterexample generation to follow.
-                self.execution_deadline += 2.0
+                self.execution_deadline += 4.0
+                if self.smt_timeout is not None:
+                    self.smt_timeout = self.smt_timeout * 2
+                    self.solver.set(timeout=self.smt_timeout)
             for description, checker in self._deferred_assumptions:
                 with ResumedTracing():
                     check_ret = checker()

crosshair/util.py

@@ -180,7 +180,9 @@ class IdKeyedDict(collections.abc.MutableMapping):
         return self.inner.__delitem__(id(k))
 
     def __iter__(self):
-        return map(id, self.inner.__iter__())
+        raise NotImplementedError
+        # No use cases for this yet, but we could do something like this:
+        # return (actual_key_object for actual_key_object, _ in self.inner.values())
 
     def __len__(self):
         return len(self.inner)

{crosshair_tool-0.0.85.dist-info → crosshair_tool-0.0.86.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crosshair-tool
-Version: 0.0.85
+Version: 0.0.86
 Summary: Analyze Python code for correctness using symbolic execution.
 Home-page: https://github.com/pschanely/CrossHair
 Author: Phillip Schanely

{crosshair_tool-0.0.85.dist-info → crosshair_tool-0.0.86.dist-info}/RECORD

@@ -1,4 +1,4 @@
-_crosshair_tracers.cpython-313-darwin.so,sha256=_6V3IkVz4bp7EZ1Bcb4keIia8cc2zcjJ5scd6kYzUSw,49912
+_crosshair_tracers.cpython-313-darwin.so,sha256=S6wfN7eGUhzJWCEJJ1_HwxCpRs3aD7uj9or1cw7noXs,49912
 crosshair/_tracers_pycompat.h,sha256=6IYnbQxrYkhBsLDAHSX25DPOwo1oYHCZUVWZ8c7YCnQ,14356
 crosshair/pure_importer.py,sha256=-t4eowrZOQmfqK1N2tjI5POoaxRGavytwMmbRivelFg,878
 crosshair/options.py,sha256=htQNgnrpoRjSNq6rfLBAF8nos-NNIwmP6tQYyI8ugsM,6775
@@ -13,7 +13,7 @@ crosshair/dynamic_typing_test.py,sha256=oyg94OXjF_2jNFy33UJjkfWnDXKnM4or2TXbxrOq
 crosshair/enforce.py,sha256=FsZx3D-KtGrhb8xdAZbPUtwvVmEu8IAn7rwf7tmkrRY,10010
 crosshair/path_search_test.py,sha256=7cqzAMXUYAtA00mq9XR5AaZChqeQyXyCfuuv53_51pk,1692
 crosshair/condition_parser.py,sha256=oquaht026eZUigh2lyaFLXYDbmENdBKjddszx0a-B3w,42647
-crosshair/util.py,sha256=OtkhDSdggqt-A7sTfp4sHa69_M7HNyD8w4gHhxcEUDo,21977
+crosshair/util.py,sha256=eddHHvkn9NnsfYahpuIF4Xp03kIiQ8EJUaliFEO4XG4,22124
 crosshair/dynamic_typing.py,sha256=jbI9FXv5-WXREQjeDtlDQladv-xCW21TUOM3qErJaJ4,11998
 crosshair/register_contract.py,sha256=EnDAxngJhKvJLFdw5kVgqaYDQ5hAZXKwAGBdXpot-AQ,10386
 crosshair/tracers.py,sha256=_jaSDgZ_pYdqacWE_msXn7W7CoSdQ_-7hlrxa891oHo,17139
@@ -23,7 +23,7 @@ crosshair/fnutil.py,sha256=X80bD2Lh4QAh-rF561r3JRxjxcuZepF3hJaxaj1GG9s,13123
 crosshair/unicode_categories.py,sha256=g4pnUPanx8KkpwI06ZUGx8GR8Myruf_EpTjyti_V4z8,333519
 crosshair/copyext.py,sha256=GBGQP9YAHoezLXwb_M59Hh1VXSou5EQt4ZmmUA0T_og,4899
 crosshair/_tracers_test.py,sha256=KpCGspjOUeZuhwTYgn_RxI4M4wMbT5rldusFDgneQ6M,3596
-crosshair/__init__.py,sha256=vw6g0DHh0Clj2rgk1Iu4a-sWjwIf5SwN6IR04XBP47s,936
+crosshair/__init__.py,sha256=BqE2fB9um9PltLa0yX7EVsyAzVpgDe5EBvIiEhQ2exI,936
 crosshair/core.py,sha256=K7147xrvcvtrP1T9oIRywq2uHMMsIu8ZwFZWBQXPozg,63634
 crosshair/path_cover.py,sha256=wV0Vy8IPDzqXQ2VI8a94FxltS9p-Y1oF17OKePjvpgs,6710
 crosshair/enforce_test.py,sha256=C6CQ4P1FjkdIJeJg3aJynp1iLDCE6BFCEVtSqXbvmQk,4665
@@ -53,13 +53,13 @@ crosshair/path_search.py,sha256=wwZjp-3E4dENnJa6BlnSq8FARkIx0PyUYc7kvH32A2k,5588
 crosshair/auditwall_test.py,sha256=VPcw_OW3nl3BkOZY4wEEtVDyTamdgqD4IjRccI2p5vI,2030
 crosshair/smtlib_test.py,sha256=edzEn19u2YYHxSzG9RrMiu2HTiEexAuehC3IlG9LuJM,511
 crosshair/register_contract_test.py,sha256=DhvKIcF3LgQfHfUSCccoA11ctCdFaQR263Pc4YUuxyk,4970
-crosshair/statespace.py,sha256=PIT5ajZZcur88_5Cs0QkPkUVa-fqKwsqgNrRNPKRoSo,41547
-crosshair/opcode_intercept_test.py,sha256=rWO84XLQF8YEQLIxvrlnJWLqMfKXgah_6AW3u_NADlQ,6189
+crosshair/statespace.py,sha256=KeIIBwBKxDgQO0ML2LvYXhS5DgmelaYF-RRXopR9lqA,41794
+crosshair/opcode_intercept_test.py,sha256=hBf04VwhaIzPdoAaqQmQJfx36yaznD9sm9x1Lb9VDm8,8790
 crosshair/main_test.py,sha256=DFXtE--616vCF1WAS576SHXO19K0LsDPzJIWNT5vuXM,14383
 crosshair/codeconfig_test.py,sha256=RnC-RnNpr6If4eHmOepDZ33MCmfyhup08dzHKCm5xWA,3350
 crosshair/watcher.py,sha256=kCCMlLe2KhW5MbEbMmixNRjRAvu5CypIAGd1V_YZ9QM,10048
 crosshair/test_util_test.py,sha256=FIOWVBMiF-zyq0pGsDQ8W6lB6_E9sGpD80dioHHETyQ,512
-crosshair/opcode_intercept.py,sha256=yNixjTRjc8R9PXO1xGF4BoQ-IAHXup7CWgUwbubRzZc,18996
+crosshair/opcode_intercept.py,sha256=z4Yb9prYE2UK21AxhjAeXyXAk5IriDuCSSCeNhbDu2A,21880
 crosshair/simplestructs.py,sha256=CiZSuHH_j_bYitaW-n7vWd_42xSyV6Jh8es3BQLlcHk,34221
 crosshair/tracers_test.py,sha256=EBK_ZCy2MsxqmEaGjo0uw9zAztW9O6fhCW_0PJxyTS8,3270
 crosshair/smtlib.py,sha256=hh-P32KHoH9BCq3oDYGp2PfOeOb8CwDj8tTkgqroLD8,689
@@ -107,13 +107,13 @@ crosshair/libimpl/binascii_test.py,sha256=LOBqLAJ77Kx8vorjVTaT3X0Z93zw4P5BvwUapM
 crosshair/libimpl/collectionslib_test.py,sha256=3h7XTToKWauMhjrEwLXVI0jT8FZKBlkvlw0oiPMmuKM,9164
 crosshair/libimpl/timelib.py,sha256=MXEFOZjFGa1-yLvmB3l3DFTLF9PSluOlmRK-ZJaA_oI,2409
 crosshair/libimpl/jsonlib_test.py,sha256=U40WJf-69dtflz75sIsl5zA3IV5R6Ltc4Z9jv_Fh-Fw,1382
-crosshair/libimpl/builtinslib.py,sha256=lMYlTJsirb-rx8RO3EU3-LwEivmWtdQ2VHfuubbsIKs,182505
+crosshair/libimpl/builtinslib.py,sha256=9qAV1xZ2oZrIrpfWQ3BXgnY0nK2Gjov4v207x43lTq4,171629
 crosshair/libimpl/mathlib_test.py,sha256=QShLCXHdv3tx5PQxcSoR0MHeZ1huaiV6d3u7C2mGOn4,1861
 crosshair/libimpl/fractionlib.py,sha256=qdbiAHHC480YdKq3wYK_piZ3UD7oT64YfuNclypMUfQ,458
 crosshair/libimpl/binascii_ch_test.py,sha256=hFqSfF1Q8jl2LNBIWaQ6vBJIIshPOmSwrR0T1Ko4Leo,1009
 crosshair/libimpl/jsonlib.py,sha256=xFTvqGKzQcCgPme1WIpNMjBPfNHVZBMNuNx0uKMYXj0,28805
-crosshair/libimpl/typeslib_test.py,sha256=Gf-EymanxMty2-B53BiT81w1CSTzoHVXvELwqiGOqxc,1083
-crosshair/libimpl/builtinslib_test.py,sha256=GmnsgjSKjkE-3cb-aQwSV5BYbNHvD-O1E8sB-hZv8f4,90270
+crosshair/libimpl/typeslib_test.py,sha256=qCeUU_c-zmuvfwHEsaYqic9wdGzs9XbDZNr6bF2Xp58,1129
+crosshair/libimpl/builtinslib_test.py,sha256=Q0DvH7Q_Ja0Tg83enhB_y_Pdau_S-bA6ztorjvgl4Mw,90275
 crosshair/libimpl/zliblib.py,sha256=XymJTKYbplpYJZ-P7GKVSY3V_8HPy5lqRFsCH1zezIk,357
 crosshair/libimpl/decimallib.py,sha256=zBKDrDZcg45oCKUkf6SIDuVpjA1Web7tD1MEQo5cjxI,177348
 crosshair/libimpl/relib_ch_test.py,sha256=zvSBF82mNQR5yEOMwwcaBOh8OpJkQeiVl85pgYVvJRA,5235
@@ -166,9 +166,9 @@ crosshair/libimpl/encodings/ascii.py,sha256=Cz1xraTkXdQ5aBKDkorX4rAvrmf877_EqzC9
 crosshair/libimpl/encodings/__init__.py,sha256=5LTEj1M-S00eZ4rfQWczAixg57vyh_9vZ5m5EKB5Ksc,680
 crosshair/libimpl/encodings/latin_1.py,sha256=ftUsPjUb9L7UKXKi9P7OAqOl9FkNP98M9jMAvseXBCQ,1242
 crosshair/libimpl/encodings/_encutil.py,sha256=nwVWqcGM1f7-hAC3Z46KnfrLzAjhfy4zaTa11uVBk6M,6828
-crosshair_tool-0.0.85.dist-info/RECORD,,
-crosshair_tool-0.0.85.dist-info/WHEEL,sha256=CAEnsYkCnsTBAHMrpKhgZUUTcGmT5qlV2Rwkjvexu2Q,111
-crosshair_tool-0.0.85.dist-info/entry_points.txt,sha256=u5FIPVn1jqn4Kzg5K_iNnbP6L4hQw5FWjQ0UMezG2VE,96
-crosshair_tool-0.0.85.dist-info/top_level.txt,sha256=2jLWtM-BWg_ZYNbNfrcds0HFZD62a6J7ZIbcgcQrRk4,29
-crosshair_tool-0.0.85.dist-info/METADATA,sha256=ceFH89wcuwsmpx0R5LKTkwTiag76wifHPC545rEm4dQ,6717
-crosshair_tool-0.0.85.dist-info/licenses/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459
+crosshair_tool-0.0.86.dist-info/RECORD,,
+crosshair_tool-0.0.86.dist-info/WHEEL,sha256=D5oYZcu7xsHPQ1lvRcEfimRZkYr_RmvD7J5S2QmS8s0,138
+crosshair_tool-0.0.86.dist-info/entry_points.txt,sha256=u5FIPVn1jqn4Kzg5K_iNnbP6L4hQw5FWjQ0UMezG2VE,96
+crosshair_tool-0.0.86.dist-info/top_level.txt,sha256=2jLWtM-BWg_ZYNbNfrcds0HFZD62a6J7ZIbcgcQrRk4,29
+crosshair_tool-0.0.86.dist-info/METADATA,sha256=8n0ualxjh4y_waUzDZfliJjet2bID8tHk6kQIiwX2-M,6717
+crosshair_tool-0.0.86.dist-info/licenses/LICENSE,sha256=NVyMvNqn1pH6RSHs6RWRcJyJvORnpgGFBlF73buqYJ0,4459

{crosshair_tool-0.0.85.dist-info → crosshair_tool-0.0.86.dist-info}/WHEEL

@@ -2,4 +2,5 @@ Wheel-Version: 1.0
 Generator: setuptools (78.1.0)
 Root-Is-Purelib: false
 Tag: cp313-cp313-macosx_10_13_x86_64
+Generator: delocate 0.13.0