crosshair-tool 0.0.56__cp39-cp39-macosx_11_0_arm64.whl → 0.0.100__cp39-cp39-macosx_11_0_arm64.whl

crosshair/opcode_intercept.py

@@ -1,29 +1,47 @@
 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, List, Mapping, Tuple, Union
 
-from crosshair.core import ATOMIC_IMMUTABLE_TYPES, CrossHairValue, register_opcode_patch
+from z3 import ExprRef  # type: ignore
+
+from crosshair.core import (
+    ATOMIC_IMMUTABLE_TYPES,
+    register_opcode_patch,
+    with_uniform_probabilities,
+)
 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 CrosshairInternal
-from crosshair.z3util import z3Not
+from crosshair.util import (
+    CROSSHAIR_EXTRA_ASSERTS,
+    CrossHairInternal,
+    CrossHairValue,
+    debug,
+)
+from crosshair.z3util import z3Not, z3Or
 
-BINARY_SUBSCR = dis.opmap["BINARY_SUBSCR"]
+BINARY_SUBSCR = dis.opmap.get("BINARY_SUBSCR", 256)
 BINARY_SLICE = dis.opmap.get("BINARY_SLICE", 256)
 BUILD_STRING = dis.opmap["BUILD_STRING"]
 COMPARE_OP = dis.opmap["COMPARE_OP"]
@@ -35,32 +53,166 @@ SET_ADD = dis.opmap["SET_ADD"]
 UNARY_NOT = dis.opmap["UNARY_NOT"]
 TO_BOOL = dis.opmap.get("TO_BOOL", 256)
 IS_OP = dis.opmap.get("IS_OP", 256)
+BINARY_MODULO = dis.opmap.get("BINARY_MODULO", 256)
+BINARY_OP = dis.opmap.get("BINARY_OP", 256)
+LOAD_COMMON_CONSTANT = dis.opmap.get("LOAD_COMMON_CONSTANT", 256)
 
 
 def frame_op_arg(frame):
     return frame.f_code.co_code[frame.f_lasti + 1]  # TODO: account for EXTENDED_ARG?
 
 
+_DEEPLY_CONCRETE_KEY_TYPES = (
+    int,
+    float,
+    str,
+    # Suble but important; when subscripting a Weak[Key|Value]Dictionary,
+    # we need to avoid creating a SimpleDict out of the backing dictionary.
+    # (because it can drop keys during iteration and fail)
+    weakref.ref,
+)
+
+
+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:
+                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_" + 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
+
+            exprs_and_values: List[Tuple[ExprRef, object]] = []
+            for value_id, value in 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):
+                    exprs_and_values.append((is_match.var, value))
+                elif is_match:
+                    return value
+            if exprs_and_values:
+                return space.smt_fanout(exprs_and_values, desc="multi_subscript")
+
+            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 LoadCommonConstantInterceptor(TracingModule):
+    """
+    As of 3.14, the bytecode generation process generates optimizations
+    for builtins.any/all when invoked on a generator expression.
+    It essentially "inlines" the logic as bytecode.
+    We need to avoid this.
+    Before entering the optimized code path, it will check that the any/all
+    function is identity-equal to the original builtin, which is loaded using
+    the LOAD_COMMON_CONSTANT opcode.
+
+    This interceptor replaces that function with a proxy that functions
+    identically but is not identity-equal (so that we avoid the optimized
+    path),
+    """
+
+    opcodes_wanted = frozenset([LOAD_COMMON_CONSTANT])
+
+    def trace_op(self, frame, codeobj, codenum):
+        CONSTANT_BUILTIN_ALL = 3
+        CONSTANT_BUILTIN_ANY = 4
+        index = frame_op_arg(frame)
+
+        def post_op():
+            expected_fn = all if index == CONSTANT_BUILTIN_ALL else any
+            if CROSSHAIR_EXTRA_ASSERTS:
+                if frame_stack_read(frame, -1) is not expected_fn:
+                    raise CrossHairInternal
+            frame_stack_write(frame, -1, lambda *a: expected_fn(*a))
+
+        if index == CONSTANT_BUILTIN_ALL or index == CONSTANT_BUILTIN_ANY:
+            COMPOSITE_TRACER.set_postop_callback(post_op, frame)
+
+
 class SymbolicSubscriptInterceptor(TracingModule):
-    opcodes_wanted = frozenset([BINARY_SUBSCR])
+    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
+                return
+
         key = frame_stack_read(frame, -1)
-        if isinstance(key, (int, float, str)):
+        if isinstance(key, _DEEPLY_CONCRETE_KEY_TYPES):
             return
         # 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)
-        elif container_type is list:
-            if not isinstance(key, slice):
-                # Nothing useful to do with concrete list and symbolic numeric index.
-                return
+        elif isinstance(key, slice) and container_type is list:
             step = key.step
             if isinstance(step, CrossHairValue) or step not in (None, 1):
                 return
@@ -110,6 +262,14 @@ class SideEffectStashingHashable:
         return 0
 
 
+class DeoptimizedPercentFormattingStr:
+    def __init__(self, value):
+        self.value = value
+
+    def __mod__(self, other):
+        return self.value.__mod__(other)
+
+
 class FormatStashingValue:
     def __init__(self, value):
         self.value = value
@@ -210,7 +370,7 @@ class BuildStringInterceptor(TracingModule):
         for offset in range(-(count), 0):
             substr = frame_stack_read(frame, offset)
             if not isinstance(substr, (str, AnySymbolicStr)):
-                raise CrosshairInternal
+                raise CrossHairInternal
             # Because we know these are all symbolic or concrete strings, it's ok to
             # not have tracing on when we do the concatenation here:
             real_result += substr
@@ -225,6 +385,7 @@ class BuildStringInterceptor(TracingModule):
 class FormatValueInterceptor(TracingModule):
     """Avoid checks and realization during FORMAT_VALUE (used by f-strings)."""
 
+    # TODO: don't we need to handle FORMAT_SIMPLE and FORMAT_WITH_SPEC?
     opcodes_wanted = frozenset([FORMAT_VALUE, CONVERT_VALUE])
 
     def trace_op(self, frame, codeobj, codenum):
@@ -258,7 +419,7 @@ class MapAddInterceptor(TracingModule):
         dict_offset = -(frame_op_arg(frame) + 2)
         dict_obj = frame_stack_read(frame, dict_offset)
         if not isinstance(dict_obj, (dict, MutableMapping)):
-            raise CrosshairInternal
+            raise CrossHairInternal
         # Key and value were swapped in Python 3.8
         key_offset, value_offset = (-2, -1) if version_info >= (3, 8) else (-1, -2)
         key = frame_stack_read(frame, key_offset)
@@ -266,7 +427,6 @@ class MapAddInterceptor(TracingModule):
         if isinstance(dict_obj, dict):
             if type(key) in ATOMIC_IMMUTABLE_TYPES:
                 # Dict and key is (deeply) concrete; continue as normal.
-                COMPOSITE_TRACER.set_postop_callback(None, frame)
                 return
             else:
                 dict_obj = SimpleDict(list(dict_obj.items()))
@@ -285,6 +445,11 @@ class MapAddInterceptor(TracingModule):
 
         # Afterwards, overwrite the interpreter's resulting dict with ours:
         def post_op():
+            old_dict_obj = frame_stack_read(frame, dict_offset + 2)
+            if CROSSHAIR_EXTRA_ASSERTS and not isinstance(
+                old_dict_obj, (dict, MutableMapping)
+            ):
+                raise CrossHairInternal("interpreter stack corruption detected")
             frame_stack_write(frame, dict_offset + 2, dict_obj)
 
         COMPOSITE_TRACER.set_postop_callback(post_op, frame)
@@ -298,7 +463,6 @@ class ToBoolInterceptor(TracingModule):
     def trace_op(self, frame: FrameType, codeobj: CodeType, codenum: int) -> None:
         input_bool = frame_stack_read(frame, -1)
         if not isinstance(input_bool, CrossHairValue):
-            COMPOSITE_TRACER.set_postop_callback(None, frame)
             return
         if isinstance(input_bool, SymbolicBool):
             # TODO: right now, we define __bool__ methods to perform realization.
@@ -327,7 +491,6 @@ class NotInterceptor(TracingModule):
     def trace_op(self, frame: FrameType, codeobj: CodeType, codenum: int) -> None:
         input_bool = frame_stack_read(frame, -1)
         if not isinstance(input_bool, CrossHairValue):
-            COMPOSITE_TRACER.set_postop_callback(None, frame)
             return
 
         if isinstance(input_bool, SymbolicBool):
@@ -358,17 +521,17 @@ class SetAddInterceptor(TracingModule):
         set_offset = -(frame_op_arg(frame) + 1)
         set_obj = frame_stack_read(frame, set_offset)
         if not isinstance(set_obj, Set):
-            raise CrosshairInternal(type(set_obj))
+            raise CrossHairInternal(type(set_obj))
         item = frame_stack_read(frame, -1)
         if isinstance(set_obj, set):
             if isinstance(item, CrossHairValue):
                 set_obj = ShellMutableSet(set_obj)
             else:
                 # Set and value are concrete; continue as normal.
-                COMPOSITE_TRACER.set_postop_callback(None, frame)
                 return
         # Have the interpreter do a fake addition, namely `set().add(1)`
-        frame_stack_write(frame, set_offset, set())
+        dummy_set: Set = set()
+        frame_stack_write(frame, set_offset, dummy_set)
         frame_stack_write(frame, -1, 1)
 
         # And do our own addition separately:
@@ -376,6 +539,12 @@ class SetAddInterceptor(TracingModule):
 
         # Later, overwrite the interpreter's result with ours:
         def post_op():
+            if CROSSHAIR_EXTRA_ASSERTS:
+                to_replace = frame_stack_read(frame, set_offset + 1)
+                if to_replace is not dummy_set:
+                    raise CrossHairInternal(
+                        f"Found an instance of {type(to_replace)} where dummy set should be."
+                    )
             frame_stack_write(frame, set_offset + 1, set_obj)
 
         COMPOSITE_TRACER.set_postop_callback(post_op, frame)
@@ -391,18 +560,36 @@ class IdentityInterceptor(TracingModule):
     def trace_op(self, frame: FrameType, codeobj: CodeType, codenum: int) -> None:
         arg1 = frame_stack_read(frame, -1)
         arg2 = frame_stack_read(frame, -2)
-        if isinstance(arg1, SymbolicBool):
+        if isinstance(arg1, SymbolicBool) and isinstance(arg2, (bool, SymbolicBool)):
             frame_stack_write(frame, -1, arg1.__ch_realize__())
-        if isinstance(arg2, SymbolicBool):
+        if isinstance(arg2, SymbolicBool) and isinstance(arg1, (bool, SymbolicBool)):
             frame_stack_write(frame, -2, arg2.__ch_realize__())
 
 
+class ModuloInterceptor(TracingModule):
+    opcodes_wanted = frozenset([BINARY_MODULO, BINARY_OP])
+    assert BINARY_MODULO != BINARY_OP
+
+    def trace_op(self, frame, codeobj, codenum):
+        left = frame_stack_read(frame, -2)
+        from crosshair.util import debug
+
+        if isinstance(left, str):
+            if codenum == BINARY_OP:
+                oparg = frame_op_arg(frame)
+                if oparg != 6:  # modulo operator, NB_REMAINDER
+                    return
+            frame_stack_write(frame, -2, DeoptimizedPercentFormattingStr(left))
+
+
 def make_registrations():
     register_opcode_patch(SymbolicSubscriptInterceptor())
     if sys.version_info >= (3, 12):
         register_opcode_patch(SymbolicSliceInterceptor())
     if sys.version_info < (3, 9):
         register_opcode_patch(ComparisonInterceptForwarder())
+    if sys.version_info >= (3, 14):
+        register_opcode_patch(LoadCommonConstantInterceptor())
     register_opcode_patch(ContainmentInterceptor())
     register_opcode_patch(BuildStringInterceptor())
     register_opcode_patch(FormatValueInterceptor())
@@ -411,3 +598,4 @@ def make_registrations():
     register_opcode_patch(NotInterceptor())
     register_opcode_patch(SetAddInterceptor())
     register_opcode_patch(IdentityInterceptor())
+    register_opcode_patch(ModuloInterceptor())

crosshair/opcode_intercept_test.py

@@ -1,11 +1,21 @@
+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
 
 
@@ -22,6 +32,101 @@ def test_dict_index():
     check_states(numstr, POST_FAIL)
 
 
+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")
+    with ResumedTracing():
+        space.add(0 <= idx)
+        space.add(idx < len(haystack))
+        ret = haystack[idx]
+    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):
+    o1 = dict()
+    options = [o1, o1, o1]
+    idx = proxy_for_type(int, "idx")
+    with ResumedTracing():
+        space.add(0 <= idx)
+        space.add(idx < 3)
+        ret = options[idx]
+        assert ret is o1
+        assert space.is_possible(idx == 0)
+        assert space.is_possible(idx == 2)
+
+
 def test_dict_key_containment():
     abc = {"two": 2, "four": 4, "six": 6}
 
@@ -34,12 +139,12 @@ def test_dict_key_containment():
     check_states(numstr, POST_FAIL)
 
 
-def test_dict_comprehension():
+def test_dict_comprehension_basic():
     with standalone_statespace as space:
         with NoTracing():
             x = proxy_for_type(int, "x")
-            space.add(x.var >= 40)
-            space.add(x.var < 50)
+        space.add(x >= 40)
+        space.add(x < 50)
         d = {k: v for k, v in ((35, 3), (x, 4))}
         with NoTracing():
             assert type(d) is not dict
@@ -48,8 +153,8 @@ def test_dict_comprehension():
                 continue
             with NoTracing():
                 assert type(k) is not int
-            assert space.is_possible((k == 43).var)
-            assert space.is_possible((k == 48).var)
+            assert space.is_possible(k == 43)
+            assert space.is_possible(k == 48)
 
 
 def test_dict_comprehension_traces_during_custom_hash():
@@ -75,9 +180,8 @@ def test_dict_comprehension_traces_during_custom_hash():
         # There is only one item:
         assert len(d) == 1
         # TODO: In theory, we shouldn't need to realize the string here (but we are):
-        # with NoTracing():
-        #     assert space.is_possible(mystr.__len__().var == 0)
-        #     assert space.is_possible(mystr.__len__().var == 1)
+        # assert space.is_possible(mystr.__len__() == 0)
+        # assert space.is_possible(mystr.__len__() == 1)
 
 
 def test_dict_comprehension_e2e():
@@ -90,15 +194,17 @@ def test_dict_comprehension_e2e():
     check_states(f, POST_FAIL)
 
 
+@pytest.mark.skipif(
+    sys.version_info >= (3, 13), reason="Negation opcode changed; TODO: fix!"
+)
 def test_not_operator_on_bool():
     with standalone_statespace as space:
         with NoTracing():
             boolval = proxy_for_type(bool, "boolval")
-            intlist = proxy_for_type(List[int], "intlist")
         inverseval = not boolval
+        assert space.is_possible(inverseval)
         with NoTracing():
             assert type(inverseval) is not bool
-            assert space.is_possible(inverseval.var)
             assert not space.is_possible(z3And(boolval.var, inverseval.var))
 
 
@@ -106,18 +212,18 @@ def test_not_operator_on_non_bool():
     with standalone_statespace as space:
         with NoTracing():
             intlist = proxy_for_type(List[int], "intlist")
-            space.add(intlist.__len__().var == 0)
+        space.add(intlist.__len__() == 0)
         notList = not intlist
         with NoTracing():
             assert notList
 
 
-def test_set_comprehension():
+def test_set_comprehension_basic():
     with standalone_statespace as space:
         with NoTracing():
             x = proxy_for_type(int, "x")
-            space.add(x.var >= 40)
-            space.add(x.var < 50)
+        space.add(x >= 40)
+        space.add(x < 50)
         result_set = {k for k in (35, x)}
         with NoTracing():
             assert type(result_set) is not set
@@ -126,8 +232,8 @@ def test_set_comprehension():
                 continue
             with NoTracing():
                 assert type(k) is not int
-            assert space.is_possible((k == 43).var)
-            assert space.is_possible((k == 48).var)
+            assert space.is_possible(k == 43)
+            assert space.is_possible(k == 48)
 
 
 def test_set_comprehension_e2e():
@@ -140,11 +246,59 @@ def test_set_comprehension_e2e():
     check_states(f, POST_FAIL)
 
 
+def test_trace_disabling_at_jump_targets(space):
+    # This replicates a corruption of the interpreter stack in 3.12
+    # under a specific bytecode layout.
+    #
+    # The origial issue was caused by neglecting to keep sys.monitor probes
+    # alive (for post-op callbacks) that could be jumped to from other
+    # locations.
+    _global_type_lookupx = {
+        1: 1,
+        bool: 2,
+        3: 3,
+    }
+    with ResumedTracing():
+        _ = {
+            k: v
+            for k, v in _global_type_lookupx.items()  # <- a new line has to be here (yes, the generated bytecode differs!)
+            if k == bool  # The iteration filter needs to alternate
+        }
+
+
 # TODO: we could implement identity comparisons on 3.8 by intercepting COMPARE_OP
 @pytest.mark.skipif(sys.version_info < (3, 9), reason="IS_OP is new in Python 3.9")
 def test_identity_operator_on_booleans():
     with standalone_statespace as space:
         with NoTracing():
             b1 = proxy_for_type(bool, "b1")
-            space.add(b1.var.__eq__(True))
+        space.add(b1)
         assert b1 is True
+
+
+@pytest.mark.skipif(sys.version_info < (3, 9), reason="IS_OP is new in Python 3.9")
+def test_identity_operator_does_not_realize_on_differing_types():
+    with standalone_statespace as space:
+        with NoTracing():
+            b1 = proxy_for_type(bool, "b1")
+            choices_made_at_start = len(space.choices_made)
+        space.add(b1)
+        fourty_two = 42  # assignment just to avoid lint errors
+        b1 is fourty_two
+        assert len(space.choices_made) == choices_made_at_start
+
+
+class IExplodeOnRepr:
+    def __repr__(self):
+        raise ValueError("boom")
+
+
+def test_postop_callback_skipped_on_exception_handler_jump(space):
+    with ResumedTracing():
+        elements = IExplodeOnRepr()
+        try:
+            ret = f"these are them: {elements!r}"
+        except ValueError:  # pragma: no cover
+            ret = None
+        # need to do something(anything) with elements so that it's on the stack:
+        type(elements)

crosshair/options.py

@@ -12,7 +12,6 @@ class AnalysisKind(enum.Enum):
     PEP316 = "PEP316"
     icontract = "icontract"
     deal = "deal"
-    hypothesis = "hypothesis"
 
     def __repr__(self):
         return f"AnalysisKind.{self.name}"