crosshair-tool 0.0.83__cp39-cp39-macosx_10_9_universal2.whl → 0.0.85__cp39-cp39-macosx_10_9_universal2.whl

crosshair/libimpl/collectionslib.py

@@ -1,4 +1,5 @@
 import collections
+import sys
 from typing import (
     Any,
     Callable,
@@ -125,8 +126,19 @@ class ListBasedDeque(collections.abc.MutableSequence, CrossHairValue, Generic[T]
         prefix.reverse()
         self._contents = prefix + self._contents
 
-    def index(self, item: T, *bounds) -> int:
-        return self._contents.index(item, *bounds)
+    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)
@@ -245,5 +257,8 @@ def make_registrations():
 
     register_type(collections.abc.MutableSet, lambda p, t=Any: p(Set[t]))  # type: ignore
 
-    register_type(collections.abc.ByteString, lambda p: p(bytes))
+    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_test.py

@@ -1,14 +1,24 @@
-import collections
+import re
+import sys
+from collections import Counter, defaultdict, deque, namedtuple
 from copy import deepcopy
-from typing import Counter, DefaultDict, Deque, Tuple
+from inspect import Parameter, Signature
+from typing import Counter, DefaultDict, Deque, NamedTuple, Tuple
 
 import pytest
 
-from crosshair.core import deep_realize, proxy_for_type, realize, standalone_statespace
+from crosshair.core import (
+    deep_realize,
+    get_constructor_signature,
+    proxy_for_type,
+    realize,
+    standalone_statespace,
+)
 from crosshair.libimpl.collectionslib import ListBasedDeque
 from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL, MessageType
 from crosshair.test_util import check_states
 from crosshair.tracers import NoTracing, ResumedTracing
+from crosshair.util import CrossHairValue
 
 
 @pytest.fixture
@@ -24,7 +34,7 @@ def test_counter_symbolic_deep(space):
 
 
 def test_counter_deep(space):
-    d = collections.Counter()
+    d = Counter()
     with ResumedTracing():
         deep_realize(d)
         deepcopy(d)
@@ -89,7 +99,11 @@ def test_deque_index_with_start_index_throws_correct_exception(test_list) -> Non
     with pytest.raises(ValueError) as context:
         test_list.index(1, 2)
 
-    assert context.match("1 is not in list")
+    if sys.version_info >= (3, 14):
+        # assert context.match(re.escape("list.index(x): x not in list"))
+        assert context.match(re.escape("deque.index(x): x not in deque"))
+    else:
+        assert context.match("1 is not in list")
 
 
 def test_deque_index_with_start_and_end_index(test_list) -> None:
@@ -103,7 +117,10 @@ def test_deque_index_with_start_and_end_index_throws_correct_exception(
     with pytest.raises(ValueError) as context:
         test_list.index(6, 0, 1)
 
-    assert context.match("6 is not in list")
+    if sys.version_info >= (3, 14):
+        assert context.match(re.escape("deque.index(x): x not in deque"))
+    else:
+        assert context.match("6 is not in list")
 
 
 def test_deque_insert(test_list) -> None:
@@ -176,7 +193,7 @@ def test_deque_extendleft_method() -> None:
         """
         Can any deque be extended by itself and form this palindrome?
 
-        post[ls]: ls != collections.deque([1, 2, 3, 3, 2, 1])
+        post[ls]: ls != deque([1, 2, 3, 3, 2, 1])
         """
         ls.extendleft(ls)
 
@@ -185,22 +202,22 @@ def test_deque_extendleft_method() -> None:
 
 def test_deque_add_symbolic_to_concrete():
     with standalone_statespace as space:
-        d = ListBasedDeque([1, 2]) + collections.deque([3, 4])
+        d = ListBasedDeque([1, 2]) + deque([3, 4])
         assert list(d) == [1, 2, 3, 4]
 
 
 def test_deque_eq():
     with standalone_statespace as space:
         assert ListBasedDeque([1, 2]) == ListBasedDeque([1, 2])
-        assert collections.deque([1, 2]) == ListBasedDeque([1, 2])
+        assert deque([1, 2]) == ListBasedDeque([1, 2])
         assert ListBasedDeque([1, 2]) != ListBasedDeque([1, 55])
-        assert collections.deque([1, 2]) != ListBasedDeque([1, 55])
+        assert deque([1, 2]) != ListBasedDeque([1, 55])
 
 
 def test_defaultdict_repr_equiv(test_list) -> None:
     def f(symbolic: DefaultDict[int, int]) -> Tuple[dict, dict]:
         """post: _[0] == _[1]"""
-        concrete = collections.defaultdict(symbolic.default_factory, symbolic.items())
+        concrete = defaultdict(symbolic.default_factory, symbolic.items())
         return (symbolic, concrete)
 
     check_states(f, CANNOT_CONFIRM)
@@ -243,16 +260,73 @@ def test_defaultdict_realize():
     with standalone_statespace:
         with NoTracing():
             d = proxy_for_type(DefaultDict[int, int], "d")
-            assert type(realize(d)) is collections.defaultdict
+            assert type(realize(d)) is defaultdict
 
 
 #
-# We don't patch namedtuple, but namedtuple performs magic like dynamic type
+# We don't patch namedtuple, but namedtuple performs magic dynamic type
 # generation, which can interfere with CrossHair.
 #
 
 
 def test_namedtuple_creation():
     with standalone_statespace:
-        # Ensure type creation doesn't raise exception:
-        Color = collections.namedtuple("Color", ("name", "hex"))
+        # Ensure type creation under trace doesn't raise exception:
+        Color = namedtuple("Color", ("name", "hex"))
+
+
+def test_namedtuple_argument_detection_untyped():
+    UntypedColor = namedtuple("UntypedColor", ("name", "hex"))
+    expected_signature = Signature(
+        parameters=[
+            Parameter("name", Parameter.POSITIONAL_OR_KEYWORD),
+            Parameter("hex", Parameter.POSITIONAL_OR_KEYWORD),
+        ],
+        return_annotation=Signature.empty,
+    )
+    assert get_constructor_signature(UntypedColor) == expected_signature
+
+
+def test_namedtuple_argument_detection_typed_with_subclass():
+    class ClassTypedColor(NamedTuple):
+        name: str
+        hex: int
+
+    expected_parameters = {
+        "name": Parameter("name", Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+        "hex": Parameter("hex", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+    }
+    assert get_constructor_signature(ClassTypedColor).parameters == expected_parameters
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9),
+    reason="Functional namedtuple field types supported on Python >= 3.9",
+)
+def test_namedtuple_argument_detection_typed_functionally():
+    FunctionallyTypedColor = NamedTuple(
+        "FunctionallyTypedColor", [("name", str), ("hex", int)]
+    )
+    expected_parameters = {
+        "name": Parameter("name", Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+        "hex": Parameter("hex", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+    }
+    assert (
+        get_constructor_signature(FunctionallyTypedColor).parameters
+        == expected_parameters
+    )
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9),
+    reason="Functional namedtuple field types supported on Python >= 3.9",
+)
+def test_namedtuple_symbolic_creation(space):
+    UntypedColor = namedtuple("Color", "name hex")
+    Color = NamedTuple("Color", [("name", str), ("hex", int)])
+    untyped_color = proxy_for_type(UntypedColor, "color")
+    assert isinstance(untyped_color.hex, CrossHairValue)
+    color = proxy_for_type(Color, "color")
+    with ResumedTracing():
+        assert space.is_possible(color.hex == 5)
+        assert space.is_possible(color.hex == 10)

crosshair/libimpl/encodings/_encutil.py

@@ -1,7 +1,12 @@
 import codecs
-from collections.abc import ByteString
+import sys
 from dataclasses import dataclass
-from typing import Dict, List, Optional, Tuple, Type, Union
+from typing import List, Optional, Tuple, Type, Union
+
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+else:
+    from collections.abc import ByteString as Buffer
 
 from crosshair.core import realize
 from crosshair.libimpl.builtinslib import AnySymbolicStr, SymbolicBytes
@@ -87,7 +92,7 @@ class StemEncoder:
     def decode(
         cls, input: bytes, errors: str = "strict"
     ) -> Tuple[Union[str, AnySymbolicStr], int]:
-        if not (isinstance(input, ByteString) and isinstance(errors, str)):
+        if not (isinstance(input, Buffer) and isinstance(errors, str)):
             raise TypeError
         parts: List[Union[str, AnySymbolicStr]] = []
         idx = 0

crosshair/libimpl/mathlib_test.py

@@ -1,6 +1,5 @@
 import math
 import sys
-import unittest
 
 import pytest
 
@@ -66,9 +65,3 @@ def test_log():
         space.add(f > 0)
         math.log(i)
         math.log(f)
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/libimpl/relib_ch_test.py

@@ -122,7 +122,7 @@ def check_search_anchored_end(text: str, flags: int) -> ResultComparison:
 
 def check_subn(text: str, flags: int) -> ResultComparison:
     """post: _"""
-    return compare_results(lambda t, f: re.subn("aa", "ba", t, f), text, flags)
+    return compare_results(lambda t, f: re.subn("aa", "ba", t, flags=f), text, flags)
 
 
 def check_lookahead(text: str) -> ResultComparison:
@@ -150,7 +150,7 @@ def check_negative_lookbehind(text: str) -> ResultComparison:
 
 def check_subn_bytes(text: bytes, flags: int) -> ResultComparison:
     """post: _"""
-    return compare_results(lambda t, f: re.subn(b"a", b"b", t, f), text, flags)
+    return compare_results(lambda t, f: re.subn(b"a", b"b", t, flags=f), text, flags)
 
 
 def check_findall_bytes(text: bytes, flags: int) -> ResultComparison:

crosshair/libimpl/timelib.py

@@ -1,27 +1,45 @@
 import time as real_time
 from inspect import Signature
 from math import isfinite
-from typing import Any, Callable
+from typing import Any, Literal
 
-from crosshair.core import FunctionInterps
+from crosshair.core import register_patch
 from crosshair.register_contract import register_contract
 from crosshair.statespace import context_statespace
 from crosshair.tracers import NoTracing
 
 
-def _gte_last(fn: Callable, value: Any) -> bool:
+class EarliestPossibleTime:
+    monotonic: float = 0.0
+    process_time: float = 0.0
+
+    def __init__(self, *a):
+        pass
+
+
+# Imprecision at high values becomes a sort of artificial problem
+_UNREALISTICALLY_LARGE_TIME_FLOAT = float(60 * 60 * 24 * 365 * 100_000)
+
+
+def _gte_last(kind: Literal["monotonic", "process_time"], value: Any) -> bool:
+    with NoTracing():
+        earliest_times = context_statespace().extra(EarliestPossibleTime)
+        threshold = getattr(earliest_times, kind)
+        setattr(earliest_times, kind, value)
+    return all([threshold <= value, value < _UNREALISTICALLY_LARGE_TIME_FLOAT])
+
+
+def _sleep(value: float) -> None:
     with NoTracing():
-        interps = context_statespace().extra(FunctionInterps)
-        previous = interps._interpretations[fn]
-        if len(previous) < 2:
-            return True
-    return value >= previous[-2]
+        earliest_times = context_statespace().extra(EarliestPossibleTime)
+    earliest_times.monotonic += value
+    return None
 
 
 def make_registrations():
     register_contract(
         real_time.time,
-        post=lambda __return__: __return__ > 0.0,
+        post=lambda __return__: __return__ > 0.0 and isfinite(__return__),
         sig=Signature(parameters=[], return_annotation=float),
     )
     register_contract(
@@ -31,23 +49,24 @@ def make_registrations():
     )
     register_contract(
         real_time.monotonic,
-        post=lambda __return__: isfinite(__return__)
-        and _gte_last(real_time.monotonic, __return__),
+        post=lambda __return__: _gte_last("monotonic", __return__)
+        and isfinite(__return__),
         sig=Signature(parameters=[], return_annotation=float),
     )
     register_contract(
         real_time.monotonic_ns,
-        post=lambda __return__: isfinite(__return__)
-        and _gte_last(real_time.monotonic_ns, __return__),
+        post=lambda __return__: _gte_last("monotonic", __return__ / 1_000_000_000),
         sig=Signature(parameters=[], return_annotation=int),
     )
     register_contract(
         real_time.process_time,
-        post=lambda __return__: _gte_last(real_time.process_time, __return__),
+        post=lambda __return__: _gte_last("process_time", __return__)
+        and isfinite(__return__),
         sig=Signature(parameters=[], return_annotation=float),
     )
     register_contract(
         real_time.process_time_ns,
-        post=lambda __return__: _gte_last(real_time.process_time_ns, __return__),
+        post=lambda __return__: _gte_last("process_time", __return__ / 1_000_000_000),
         sig=Signature(parameters=[], return_annotation=int),
     )
+    register_patch(real_time.sleep, _sleep)

crosshair/libimpl/timelib_test.py

@@ -2,7 +2,7 @@ import time
 
 import pytest
 
-from crosshair.statespace import CONFIRMED, POST_FAIL
+from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL
 from crosshair.test_util import check_states
 
 
@@ -69,4 +69,14 @@ def test_monotonic_ns():
         start = time.monotonic_ns()
         return time.monotonic_ns() - start
 
-    check_states(f, CONFIRMED)
+    check_states(f, CANNOT_CONFIRM)
+
+
+def test_sleep():
+    def f():
+        """post: _ >= 60.0"""
+        start = time.monotonic()
+        time.sleep(60.01)
+        return time.monotonic() - start
+
+    check_states(f, CANNOT_CONFIRM)

crosshair/lsp_server.py

@@ -86,7 +86,7 @@ def publish_messages(
             if message.state < MessageType.PRE_UNSAT:
                 continue
             # TODO: consider server.show_message_log()ing the long description
-            diagnostics.append(get_diagnostic(message, doc.lines if doc else ()))
+            diagnostics.append(get_diagnostic(message, doc.lines if doc else []))
         server.publish_diagnostics(uri, diagnostics)
         if not diagnostics:
             # After we publish an empty set, it's safe to forget about the file:

crosshair/main.py

@@ -448,7 +448,9 @@ def run_watch_loop(
             active_messages = {}
         else:
             time.sleep(0.1)
-            max_uninteresting_iterations *= 2
+            max_uninteresting_iterations = min(
+                max_uninteresting_iterations * 2, 100_000_000
+            )
         for curstats, messages in watcher.run_iteration(max_uninteresting_iterations):
             messages = [m for m in messages if m.state > MessageType.PRE_UNSAT]
             stats.update(curstats)

crosshair/objectproxy_test.py

@@ -1,4 +1,4 @@
-import unittest
+import pytest
 
 from crosshair.objectproxy import ObjectProxy
 
@@ -11,17 +11,13 @@ class ObjectWrap(ObjectProxy):
         return object.__getattribute__(self, "_o")
 
 
-class ObjectProxyTest(unittest.TestCase):
+class TestObjectProxy:
     def test_object_proxy(self) -> None:
         i = [1, 2, 3]
         proxy = ObjectWrap(i)
-        self.assertEqual(i, proxy)
+        assert i == proxy
         proxy.append(4)
-        self.assertEqual([1, 2, 3, 4], proxy)
-        self.assertEqual([1, 2, 3, 4, 5], proxy + [5])
-        self.assertEqual([2, 3], proxy[1:3])
-        self.assertEqual([1, 2, 3, 4], proxy)
-
-
-if __name__ == "__main__":
-    unittest.main()
+        assert [1, 2, 3, 4] == proxy
+        assert [1, 2, 3, 4, 5] == proxy + [5]
+        assert [2, 3] == proxy[1:3]
+        assert [1, 2, 3, 4] == proxy

crosshair/opcode_intercept.py

@@ -26,10 +26,10 @@ from crosshair.tracers import (
     frame_stack_read,
     frame_stack_write,
 )
-from crosshair.util import CrossHairInternal, CrossHairValue
+from crosshair.util import CROSSHAIR_EXTRA_ASSERTS, CrossHairInternal, CrossHairValue
 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"]
@@ -61,11 +61,17 @@ _DEEPLY_CONCRETE_KEY_TYPES = (
 
 
 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, _DEEPLY_CONCRETE_KEY_TYPES):
             return
@@ -284,6 +290,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):
@@ -344,7 +351,9 @@ 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 not isinstance(old_dict_obj, (dict, MutableMapping)):
+            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)
 
@@ -426,7 +435,8 @@ class SetAddInterceptor(TracingModule):
                 # Set and value are concrete; continue as normal.
                 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:
@@ -434,6 +444,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)
@@ -449,9 +465,9 @@ 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__())
 
 
@@ -466,7 +482,7 @@ class ModuloInterceptor(TracingModule):
         if isinstance(left, str):
             if codenum == BINARY_OP:
                 oparg = frame_op_arg(frame)
-                if oparg != 6:  # modulo operator (determined experimentally)
+                if oparg != 6:  # modulo operator, NB_REMAINDER
                     return
             frame_stack_write(frame, -2, DeoptimizedPercentFormattingStr(left))
 

crosshair/opcode_intercept_test.py

@@ -60,7 +60,7 @@ 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")
@@ -139,7 +139,7 @@ def test_not_operator_on_non_bool():
             assert notList
 
 
-def test_set_comprehension():
+def test_set_comprehension_basic():
     with standalone_statespace as space:
         with NoTracing():
             x = proxy_for_type(int, "x")
@@ -195,3 +195,14 @@ def test_identity_operator_on_booleans():
             b1 = proxy_for_type(bool, "b1")
         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)
+        _ = b1 is 42  # noqa: F632
+        assert len(space.choices_made) == choices_made_at_start

crosshair/tracers.py

@@ -132,6 +132,14 @@ def handle_call_function_ex_3_13(frame) -> CallStackInfo:
         return (idx, NULL_POINTER, kwargs_idx)  # type: ignore
 
 
+def handle_call_function_ex_3_14(frame) -> CallStackInfo:
+    callable_idx, kwargs_idx = -4, -1
+    try:
+        return (callable_idx, frame_stack_read(frame, callable_idx), kwargs_idx)
+    except ValueError:
+        return (callable_idx, NULL_POINTER, kwargs_idx)  # type: ignore
+
+
 def handle_call_method(frame) -> CallStackInfo:
     idx = -(frame.f_code.co_code[frame.f_lasti + 1] + 2)
     try:
@@ -148,9 +156,13 @@ _CALL_HANDLERS: Dict[int, Callable[[object], CallStackInfo]] = {
     CALL_KW: handle_call_kw,
     CALL_FUNCTION: handle_call_function,
     CALL_FUNCTION_KW: handle_call_function_kw,
-    CALL_FUNCTION_EX: handle_call_function_ex_3_13
-    if sys.version_info >= (3, 13)
-    else handle_call_function_ex_3_6,
+    CALL_FUNCTION_EX: handle_call_function_ex_3_14
+    if sys.version_info >= (3, 14)
+    else (
+        handle_call_function_ex_3_13
+        if sys.version_info >= (3, 13)
+        else handle_call_function_ex_3_6
+    ),
     CALL_METHOD: handle_call_method,
 }
 
@@ -236,12 +248,18 @@ class TracingModule:
                 target = __func
 
         if kwargs_idx is not None:
-            kwargs_dict = frame_stack_read(frame, kwargs_idx)
-            replacement_kwargs = {
-                key.__ch_realize__() if hasattr(key, "__ch_realize__") else key: val
-                for key, val in kwargs_dict.items()
-            }
-            frame_stack_write(frame, kwargs_idx, replacement_kwargs)
+            try:
+                kwargs_dict = frame_stack_read(frame, kwargs_idx)
+            except ValueError:
+                pass
+            else:
+                replacement_kwargs = {
+                    # TODO: I don't think it's safe to realize in the middle of a tracing operation.
+                    # Need to confirm with test. I guess we have to wrap the callable instead?
+                    key.__ch_realize__() if hasattr(key, "__ch_realize__") else key: val
+                    for key, val in kwargs_dict.items()
+                }
+                frame_stack_write(frame, kwargs_idx, replacement_kwargs)
 
         if isinstance(target, Untracable):
             return None

crosshair/type_repo.py

@@ -6,7 +6,7 @@ from typing import Dict, List, Optional, Type
 import z3  # type: ignore
 
 from crosshair.tracers import NoTracing
-from crosshair.util import CrossHairInternal, CrossHairValue
+from crosshair.util import CrossHairInternal, CrossHairValue, is_hashable
 from crosshair.z3util import z3Eq, z3Not
 
 _MAP: Optional[Dict[type, List[type]]] = None
@@ -67,7 +67,7 @@ def get_subclass_map() -> Dict[type, List[type]]:
             except ImportError:
                 continue
             for _, cls in module_classes:
-                if _class_known_to_be_copyable(cls):
+                if _class_known_to_be_copyable(cls) and is_hashable(cls):
                     classes.add(cls)
         subclass = collections.defaultdict(list)
         for cls in classes: