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

crosshair/libimpl/collectionslib.py

@@ -126,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)

crosshair/libimpl/collectionslib_test.py

@@ -1,3 +1,4 @@
+import re
 import sys
 from collections import Counter, defaultdict, deque, namedtuple
 from copy import deepcopy
@@ -98,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:
@@ -112,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:

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/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/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/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,23 +14,32 @@ 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 CrossHairInternal, CrossHairValue
+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"]
@@ -60,19 +70,119 @@ _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])
+    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
         # 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)
@@ -84,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):
@@ -345,7 +420,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)
 
@@ -427,7 +504,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:
@@ -435,6 +513,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)
@@ -450,9 +534,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__())
 
 
@@ -467,7 +551,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

@@ -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):
@@ -60,7 +139,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 +218,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 +274,15 @@ 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)
+        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/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