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

crosshair/core.py

@@ -11,7 +11,6 @@
 import enum
 import functools
 import inspect
-import itertools
 import linecache
 import os.path
 import sys
@@ -23,6 +22,8 @@ from collections import ChainMap, defaultdict, deque
 from contextlib import ExitStack
 from dataclasses import dataclass, replace
 from inspect import BoundArguments, Signature, isabstract
+from time import monotonic
+from traceback import StackSummary, extract_stack, extract_tb, format_exc
 from typing import (
     Any,
     Callable,
@@ -33,11 +34,9 @@ from typing import (
     List,
     Mapping,
     MutableMapping,
-    NewType,
     Optional,
     Sequence,
     Set,
-    Sized,
     Tuple,
     Type,
     TypeVar,
@@ -73,12 +72,11 @@ from crosshair.fnutil import (
     resolve_signature,
 )
 from crosshair.options import DEFAULT_OPTIONS, AnalysisOptions, AnalysisOptionSet
-from crosshair.register_contract import get_contract
+from crosshair.register_contract import clear_contract_registrations, get_contract
 from crosshair.statespace import (
     AnalysisMessage,
     CallAnalysis,
     MessageType,
-    NotDeterministic,
     RootNode,
     SimpleStateSpace,
     StateSpace,
@@ -95,6 +93,7 @@ from crosshair.tracers import (
     PatchingModule,
     ResumedTracing,
     TracingModule,
+    check_opcode_support,
     is_tracing,
 )
 from crosshair.type_repo import get_subclass_map
@@ -102,13 +101,16 @@ from crosshair.util import (
     ATOMIC_IMMUTABLE_TYPES,
     UNABLE_TO_REPR_TEXT,
     AttributeHolder,
-    CrosshairInternal,
+    CrossHairInternal,
     CrosshairUnsupported,
+    CrossHairValue,
     EvalFriendlyReprContext,
     IdKeyedDict,
     IgnoreAttempt,
+    NotDeterministic,
     ReferencedIdentifier,
     UnexploredPath,
+    ch_stack,
     debug,
     eval_friendly_repr,
     format_boundargs,
@@ -121,28 +123,31 @@ from crosshair.util import (
     samefile,
     smtlib_typename,
     sourcelines,
-    test_stack,
     type_args_of,
     warn,
 )
 
+if sys.version_info >= (3, 12):
+    from typing import TypeAliasType
+
+    TypeAliasTypes = (TypeAliasType,)
+else:
+    TypeAliasTypes = ()
+
+
 _MISSING = object()
 
 
 _OPCODE_PATCHES: List[TracingModule] = []
 
 _PATCH_REGISTRATIONS: Dict[Callable, Callable] = {}
-_PATCH_FN_TYPE_REGISTRATIONS: Dict[type, Callable] = {}
 
 
-class Patched(TracingModule):
+class Patched:
     def __enter__(self):
         COMPOSITE_TRACER.patching_module.add(_PATCH_REGISTRATIONS)
-        COMPOSITE_TRACER.patching_module.fn_type_overrides = (
-            _PATCH_FN_TYPE_REGISTRATIONS
-        )
         if len(_OPCODE_PATCHES) == 0:
-            raise CrosshairInternal("Opcode patches haven't been loaded yet.")
+            raise CrossHairInternal("Opcode patches haven't been loaded yet.")
         for module in _OPCODE_PATCHES:
             COMPOSITE_TRACER.push_module(module)
         self.pushed = _OPCODE_PATCHES[:]
@@ -152,7 +157,6 @@ class Patched(TracingModule):
         for module in reversed(self.pushed):
             COMPOSITE_TRACER.pop_config(module)
         COMPOSITE_TRACER.patching_module.pop(_PATCH_REGISTRATIONS)
-        COMPOSITE_TRACER.patching_module.fn_type_overrides = {}
         return False
 
 
@@ -174,11 +178,46 @@ class _StandaloneStatespace(ExitStack):
 standalone_statespace = _StandaloneStatespace()
 
 
+def suspected_proxy_intolerance_exception(exc_value: Exception) -> bool:
+    # NOTE: this is an intentionally very hacky function that is used to
+    # skip iterations where a symbolic is used in some function that can't
+    # accept it.
+    # As the standard library gets more and more support, this is
+    # less necessary.
+    # Although it would still provide value for 3rd party libraries
+    # implemented in C, the long-term goal is to remove it and just let
+    # CrossHair be noisy where it isn't supported.
+
+    if not isinstance(exc_value, TypeError):
+        return False
+    exc_str = str(exc_value)
+    atomic_symbolic = "SymbolicInt" in exc_str or "SymbolicFloat" in exc_str
+    if (
+        atomic_symbolic
+        or "SymbolicStr" in exc_str
+        or "__hash__ method should return an integer" in exc_str
+        or "expected string or bytes-like object" in exc_str
+    ):
+        if (
+            "can only concatenate" in exc_str
+            or "NoneType" in exc_str
+            or "object is not callable" in exc_str
+        ):
+            # https://github.com/pschanely/CrossHair/issues/234
+            # (the three conditions above correspond to examples 2, 3, and 4)
+            return False
+        if atomic_symbolic and "object is not iterable" in exc_str:
+            # https://github.com/pschanely/CrossHair/issues/322
+            return False
+        return True
+    return False
+
+
 class ExceptionFilter:
     analysis: CallAnalysis
     ignore: bool = False
     ignore_with_confirmation: bool = False
-    user_exc: Optional[Tuple[BaseException, traceback.StackSummary]] = None
+    user_exc: Optional[Tuple[BaseException, StackSummary]] = None
     expected_exceptions: Tuple[Type[BaseException], ...]
 
     def __init__(
@@ -212,24 +251,24 @@ class ExceptionFilter:
                 self.ignore = True
                 self.analysis = CallAnalysis(VerificationStatus.CONFIRMED)
                 return True
-            if isinstance(exc_value, TypeError):
-                exc_str = str(exc_value)
-                if (
-                    "SymbolicStr" in exc_str
-                    or "SymbolicInt" in exc_str
-                    or "SymbolicFloat" in exc_str
-                    or "__hash__ method should return an integer" in exc_str
-                    or "expected string or bytes-like object" in exc_str
-                ):
-                    # Ideally we'd attempt literal strings after encountering this.
-                    # See https://github.com/pschanely/CrossHair/issues/8
-                    debug("Proxy intolerace at: ", traceback.format_exc())
-                    raise CrosshairUnsupported("Detected proxy intolerance: " + exc_str)
+            if suspected_proxy_intolerance_exception(exc_value):
+                # Ideally we'd attempt literal strings after encountering this.
+                # See https://github.com/pschanely/CrossHair/issues/8
+                debug("Proxy intolerace:", exc_value, "at", format_exc())
+                raise CrosshairUnsupported("Detected proxy intolerance")
             if isinstance(exc_value, (Exception, PreconditionFailed)):
-                if isinstance(exc_value, z3.Z3Exception):
-                    return False  # internal issue: re-raise
+                if isinstance(
+                    exc_value,
+                    (
+                        z3.Z3Exception,  # internal issue, re-raise
+                        NotDeterministic,  # cannot continue to use the solver, re-raise
+                    ),
+                ):
+                    return False
                 # Most other issues are assumed to be user-facing exceptions:
-                self.user_exc = (exc_value, traceback.extract_tb(sys.exc_info()[2]))
+                lower_frames = extract_tb(sys.exc_info()[2])
+                higher_frames = extract_stack()[:-2]
+                self.user_exc = (exc_value, StackSummary(higher_frames + lower_frames))
                 self.analysis = CallAnalysis(VerificationStatus.REFUTED)
                 return True  # suppress user-level exception
             return False  # re-raise resource and system issues
@@ -246,13 +285,9 @@ def realize(value: Any) -> Any:
             return value
 
 
-def deep_realize(value: _T) -> _T:
+def deep_realize(value: _T, memo: Optional[Dict] = None) -> _T:
     with NoTracing():
-        return deepcopyext(value, CopyMode.REALIZE, {})
-
-
-class CrossHairValue:
-    pass
+        return deepcopyext(value, CopyMode.REALIZE, {} if memo is None else memo)
 
 
 def normalize_pytype(typ: Type) -> Type:
@@ -278,7 +313,7 @@ def normalize_pytype(typ: Type) -> Type:
 
 def python_type(o: object) -> Type:
     if is_tracing():
-        raise CrosshairInternal("should not be tracing while getting pytype")
+        raise CrossHairInternal("should not be tracing while getting pytype")
     if hasattr(type(o), "__ch_pytype__"):
         obj_type = o.__ch_pytype__()  # type: ignore
         if hasattr(obj_type, "__origin__"):
@@ -288,17 +323,51 @@ def python_type(o: object) -> Type:
         return type(o)
 
 
-def with_realized_args(fn: Callable) -> Callable:
+def class_with_realized_methods(cls: _T) -> _T:
+    overrides = {
+        method_name: with_realized_args(method)
+        for method_name, method in inspect.getmembers(cls)
+        if callable(method) and not method_name.startswith("_")
+    }
+    return type(cls.__name__, (cls,), overrides)  # type: ignore
+
+
+def with_realized_args(fn: Callable, deep=False) -> Callable:
+    realize_fn = deep_realize if deep else realize
+
     def realizer(*a, **kw):
         with NoTracing():
-            a = map(realize, a)
-            kw = {k: realize(v) for (k, v) in kw.items()}
-            return fn(*a, **kw)
+            a = [realize_fn(arg) for arg in a]
+            kw = {k: realize_fn(v) for (k, v) in kw.items()}
+        # You might think we don't need tracing here, but some operations can invoke user-defined behavior:
+        return fn(*a, **kw)
 
     functools.update_wrapper(realizer, fn)
     return realizer
 
 
+def with_checked_self(pytype, method_name):
+    # This is used to patch methods on native python types to handle
+    # the (unlikely) possibility of them getting called on a symbolic
+    # directly (e.g. `map(dict.pop, ...)`)
+    #
+    # Generally, we apply this patch when the method takes no arguments
+    # and has a meaningful return value.
+    native_method = getattr(pytype, method_name)
+
+    def with_checked_self(self, *a, **kw):
+        with NoTracing():
+            if hasattr(self, "__ch_pytype__"):
+                if python_type(self) is pytype:
+                    bound_method = getattr(self, method_name)
+                    with ResumedTracing():
+                        return bound_method(*a, **kw)
+        return native_method(self, *a, **kw)
+
+    functools.update_wrapper(with_checked_self, native_method)
+    return with_checked_self
+
+
 def with_symbolic_self(symbolic_cls: Type, fn: Callable):
     def call_with_symbolic_self(self, *args, **kwargs):
         with NoTracing():
@@ -308,7 +377,8 @@ def with_symbolic_self(symbolic_cls: Type, fn: Callable):
             elif any(isinstance(a, CrossHairValue) for a in args) or (
                 kwargs and any(isinstance(a, CrossHairValue) for a in kwargs.values())
             ):
-                self = symbolic_cls._smt_promote_literal(self)
+                # NOTE: _ch_create_from_literal is suppoerted for very few types right now
+                self = symbolic_cls._ch_create_from_literal(self)
                 target_fn = getattr(symbolic_cls, fn.__name__)
             else:
                 args = map(realize, args)
@@ -359,7 +429,7 @@ def choose_type(space: StateSpace, from_type: Type, varname: str) -> Optional[Ty
             probability_true=probability_true,
         ):
             return typ
-    raise CrosshairInternal
+    raise CrossHairInternal
 
 
 def get_constructor_signature(cls: Type) -> Optional[inspect.Signature]:
@@ -369,24 +439,30 @@ def get_constructor_signature(cls: Type) -> Optional[inspect.Signature]:
         sig = resolve_signature(cls)
         if isinstance(sig, inspect.Signature):
             return sig
+
+    applicable_sigs: List[Signature] = []
     new_fn = cls.__new__
-    sig = resolve_signature(new_fn)
-    # TODO: merge the type signatures of __init__ and __new__, pulling the
-    # most specific types from each.
-    # Fall back to __init__ if we don't have types:
-    if isinstance(sig, str) or all(
-        p.annotation is Signature.empty for p in sig.parameters.values()
-    ):
-        init_fn = cls.__init__
-        if init_fn is not object.__init__:
-            sig = resolve_signature(init_fn)
-        else:
-            return inspect.Signature([])
-    if isinstance(sig, inspect.Signature):
-        # strip first argument
-        newparams = list(sig.parameters.values())[1:]
-        return sig.replace(parameters=newparams)
-    return None
+    if new_fn is not object.__new__:
+        sig = resolve_signature(new_fn)
+        if not isinstance(sig, str):
+            applicable_sigs.append(sig)
+    init_fn = cls.__init__
+    if init_fn is not object.__init__:
+        sig = resolve_signature(init_fn)
+        if not isinstance(sig, str):
+            sig = sig.replace(
+                return_annotation=object
+            )  # make return types compatible (& use __new__'s return)
+            applicable_sigs.append(sig)
+    if len(applicable_sigs) == 0:
+        return inspect.Signature([])
+    if len(applicable_sigs) == 2:
+        sig = dynamic_typing.intersect_signatures(*applicable_sigs)
+    else:
+        sig = applicable_sigs[0]
+    # strip first argument ("self" or "cls")
+    newparams = list(sig.parameters.values())[1:]
+    return sig.replace(parameters=newparams)
 
 
 _TYPE_HINTS = IdKeyedDict()
@@ -425,7 +501,7 @@ def proxy_for_class(typ: Type, varname: str) -> object:
         # postconditions can be invalidated when the class has invariants.
         raise IgnoreAttempt
     except Exception as e:
-        debug("Root-cause type construction traceback:", test_stack(e.__traceback__))
+        debug("Root-cause type construction traceback:", ch_stack(currently_handling=e))
         raise CrosshairUnsupported(
             f"error constructing {typename} instance: {name_of_type(type(e))}: {e}",
         ) from e
@@ -440,24 +516,32 @@ def proxy_for_class(typ: Type, varname: str) -> object:
         return f"{repr(typ)}({format_boundargs(realized_args)})"
 
     reprer.reprs[obj] = regenerate_construction_string
-
-    debug("repr register lazy", hex(id(obj)), typename)
     return obj
 
 
 def register_patch(entity: Callable, patch_value: Callable):
     if entity in _PATCH_REGISTRATIONS:
-        raise CrosshairInternal(f"Doubly registered patch: {entity}")
+        raise CrossHairInternal(f"Doubly registered patch: {entity}")
     _PATCH_REGISTRATIONS[entity] = patch_value
 
 
-def register_fn_type_patch(typ: type, patch_value: Callable[[Callable], Callable]):
-    if typ in _PATCH_FN_TYPE_REGISTRATIONS:
-        raise CrosshairInternal(f"Doubly registered fn type patch: {typ}")
-    _PATCH_FN_TYPE_REGISTRATIONS[typ] = patch_value
+def _reset_all_registrations():
+    global _SIMPLE_PROXIES
+    _SIMPLE_PROXIES.clear()
+    global _PATCH_REGISTRATIONS
+    _PATCH_REGISTRATIONS.clear()
+    global _OPCODE_PATCHES
+    _OPCODE_PATCHES.clear()
+    clear_contract_registrations()
 
 
 def register_opcode_patch(module: TracingModule) -> None:
+    if type(module) in map(type, _OPCODE_PATCHES):
+        raise CrossHairInternal(
+            f"Doubly registered opcode patch module type: {type(module)}"
+        )
+    check_opcode_support(module.opcodes_wanted)
+
     _OPCODE_PATCHES.append(module)
 
 
@@ -473,15 +557,18 @@ class SymbolicFactory:
         self.pytype: Any = pytype
         self.varname = varname
 
+    def get_suffixed_varname(self, suffix: str):
+        return self.varname + suffix + self.space.uniq()
+
     @overload
     def __call__(
         self, typ: Callable[..., _T], suffix: str = "", allow_subtypes: bool = True
-    ) -> _T:
-        ...
+    ) -> _T: ...
 
     @overload
-    def __call__(self, typ: Any, suffix: str = "", allow_subtypes: bool = True) -> Any:
-        ...
+    def __call__(
+        self, typ: Any, suffix: str = "", allow_subtypes: bool = True
+    ) -> Any: ...
 
     def __call__(self, typ, suffix: str = "", allow_subtypes: bool = True):
         """
@@ -497,12 +584,12 @@ class SymbolicFactory:
         """
         return proxy_for_type(
             typ,
-            self.varname + suffix + self.space.uniq(),
+            self.get_suffixed_varname(suffix),
             allow_subtypes=allow_subtypes,
         )
 
 
-_SIMPLE_PROXIES: MutableMapping[object, Callable] = {}
+_SIMPLE_PROXIES: MutableMapping[type, Callable] = {}
 
 SymbolicCreationCallback = Union[
     # Sadly Callable[] doesn't support variable arguments. Just enumerate:
@@ -528,7 +615,7 @@ def register_type(typ: Type, creator: SymbolicCreationCallback) -> None:
         typ
     ), f'Only origin types may be registered, not "{typ}": try "{origin_of(typ)}" instead.'
     if typ in _SIMPLE_PROXIES:
-        raise CrosshairInternal(f'Duplicate type "{typ}" registered')
+        raise CrossHairInternal(f'Duplicate type "{typ}" registered')
     _SIMPLE_PROXIES[typ] = creator
 
 
@@ -566,8 +653,7 @@ def proxy_for_type(
     typ: Callable[..., _T],
     varname: str,
     allow_subtypes: bool = False,
-) -> _T:
-    ...
+) -> _T: ...
 
 
 @overload
@@ -575,8 +661,7 @@ def proxy_for_type(
     typ: Any,
     varname: str,
     allow_subtypes: bool = False,
-) -> Any:
-    ...
+) -> Any: ...
 
 
 def proxy_for_type(
@@ -589,6 +674,11 @@ def proxy_for_type(
         typ = normalize_pytype(typ)
         origin = origin_of(typ)
         type_args = type_args_of(typ)
+        while isinstance(origin, TypeAliasTypes):
+            type_var_bindings = dict(zip(origin.__type_params__, type_args))
+            unified = dynamic_typing.realize(origin.__value__, type_var_bindings)
+            return proxy_for_type(unified, varname, allow_subtypes)
+
         # special cases
         if isinstance(typ, type) and issubclass(typ, enum.Enum):
             enum_values = list(typ)  # type:ignore
@@ -598,8 +688,10 @@ def proxy_for_type(
                 if space.smt_fork(desc="choose_enum_" + str(enum_value)):
                     return enum_value
             return enum_values[-1]
-        # It's easy to forget to import crosshair.core_and_libs; check:
-        assert _SIMPLE_PROXIES, "No proxy type registrations exist"
+        if not _SIMPLE_PROXIES:
+            from crosshair.core_and_libs import _make_registrations
+
+            _make_registrations()
         proxy_factory = _SIMPLE_PROXIES.get(origin)
         if proxy_factory:
             recursive_proxy_factory = SymbolicFactory(space, typ, varname)
@@ -618,7 +710,7 @@ _ARG_GENERATION_RENAMES: Dict[str, Callable] = {}
 
 def gen_args(sig: inspect.Signature) -> inspect.BoundArguments:
     if is_tracing():
-        raise CrosshairInternal
+        raise CrossHairInternal
     args = sig.bind_partial()
     space = context_statespace()
     for param in sig.parameters.values():
@@ -717,7 +809,7 @@ class ConditionCheckable(Checkable):
             "assuming preconditions: ",
             ",".join([p.expr_source for p in conditions.pre]),
         )
-        options.deadline = time.monotonic() + options.per_condition_timeout
+        options.deadline = monotonic() + options.per_condition_timeout
 
         with condition_parser(options.analysis_kind):
             analysis = analyze_calltree(options, conditions)
@@ -765,6 +857,9 @@ class ClampedCheckable(Checkable):
         self.cls_file = filename
         self.cls_start_line = start_line
 
+    def __repr__(self) -> str:
+        return f"ClampedCheckable({self.checkable})"
+
     def analyze(self) -> Iterable[AnalysisMessage]:
         cls_file = self.cls_file
         ret = []
@@ -803,7 +898,7 @@ def analyze_any(
     elif inspect.ismodule(entity):
         yield from analyze_module(cast(types.ModuleType, entity), options)
     else:
-        raise CrosshairInternal("Entity type not analyzable: " + str(type(entity)))
+        raise CrossHairInternal("Entity type not analyzable: " + str(type(entity)))
 
 
 def analyze_module(
@@ -1045,6 +1140,47 @@ class CallTreeAnalysis:
     num_confirmed_paths: int = 0
 
 
+class MessageGenerator:
+    def __init__(self, fn: Callable):
+        self.filename = ""
+        self.start_lineno = 0
+        if hasattr(fn, "__code__"):
+            code_obj = fn.__code__
+            self.filename = code_obj.co_filename
+            self.start_lineno = code_obj.co_firstlineno
+            _, _, lines = sourcelines(fn)
+            self.end_lineno = self.start_lineno + len(lines)
+
+    def make(
+        self,
+        message_type: MessageType,
+        detail: str,
+        suggested_filename: Optional[str],
+        suggested_lineno: int,
+        tb: str,
+    ) -> AnalysisMessage:
+        if (
+            suggested_filename is not None
+            and (os.path.abspath(suggested_filename) == os.path.abspath(self.filename))
+            and (self.start_lineno <= suggested_lineno <= self.end_lineno)
+        ):
+            return AnalysisMessage(
+                message_type, detail, suggested_filename, suggested_lineno, 0, tb
+            )
+        else:
+            exprline = "<unknown>"
+            if suggested_filename is not None:
+                lines = linecache.getlines(suggested_filename)
+                try:
+                    exprline = lines[suggested_lineno - 1].strip()
+                except IndexError:
+                    pass
+            detail = f'"{exprline}" yields {detail}'
+            return AnalysisMessage(
+                message_type, detail, self.filename, self.start_lineno, 0, tb
+            )
+
+
 def analyze_calltree(
     options: AnalysisOptions, conditions: Conditions
 ) -> CallTreeAnalysis:
@@ -1068,9 +1204,9 @@ def analyze_calltree(
     max_uninteresting_iterations = options.get_max_uninteresting_iterations()
     patched = Patched()
     # TODO clean up how encofrced conditions works here?
-    with enforced_conditions, patched:
+    with patched:
         for i in range(1, options.max_iterations + 1):
-            start = time.monotonic()
+            start = monotonic()
             if start > options.deadline:
                 debug("Exceeded condition timeout, stopping")
                 break
@@ -1107,6 +1243,25 @@ def analyze_calltree(
                             call_analysis.failing_precondition_reason
                         )
 
+            except NotDeterministic:
+                # TODO: Improve nondeterminism helpfulness
+                tb = extract_tb(sys.exc_info()[2])
+                frame_filename, frame_lineno = frame_summary_for_fn(
+                    conditions.src_fn, tb
+                )
+                msg_gen = MessageGenerator(conditions.src_fn)
+                call_analysis = CallAnalysis(
+                    VerificationStatus.REFUTED,
+                    [
+                        msg_gen.make(
+                            MessageType.EXEC_ERR,
+                            "NotDeterministic: Found a different execution paths after making the same decisions",
+                            frame_filename,
+                            frame_lineno,
+                            traceback.format_exc(),
+                        )
+                    ],
+                )
             except UnexploredPath:
                 call_analysis = CallAnalysis(VerificationStatus.UNKNOWN)
             except IgnoreAttempt:
@@ -1183,7 +1338,7 @@ PathCompeltionCallback = Callable[
         BoundArguments,
         Any,
         Optional[BaseException],
-        Optional[traceback.StackSummary],
+        Optional[StackSummary],
     ],
     bool,
 ]
@@ -1199,12 +1354,12 @@ def explore_paths(
     """
     Runs a path exploration for use cases beyond invariant checking.
     """
-    condition_start = time.monotonic()
+    condition_start = monotonic()
     breakout = False
     max_uninteresting_iterations = options.get_max_uninteresting_iterations()
     for i in range(1, options.max_iterations + 1):
         debug("Iteration ", i)
-        itr_start = time.monotonic()
+        itr_start = monotonic()
         if itr_start > condition_start + options.per_condition_timeout:
             debug(
                 "Stopping due to --per_condition_timeout=",
@@ -1225,7 +1380,7 @@ def explore_paths(
                 args = deepcopyext(pre_args, CopyMode.REGULAR, {})
                 ret: object = None
                 user_exc: Optional[BaseException] = None
-                user_exc_stack: Optional[traceback.StackSummary] = None
+                user_exc_stack: Optional[StackSummary] = None
                 with ExceptionFilter() as efilter, ResumedTracing():
                     ret = fn(args)
                 if efilter.user_exc:
@@ -1266,102 +1421,6 @@ def explore_paths(
                     break
 
 
-class UnEqual:
-    pass
-
-
-_UNEQUAL = UnEqual()
-
-
-def deep_eq(old_val: object, new_val: object, visiting: Set[Tuple[int, int]]) -> bool:
-    # TODO: test just about all of this
-    if old_val is new_val:
-        return True
-    if type(old_val) != type(new_val):
-        return False
-    visit_key = (id(old_val), id(new_val))
-    if visit_key in visiting:
-        return True
-    visiting.add(visit_key)
-    try:
-        with NoTracing():
-            is_ch_value = isinstance(old_val, CrossHairValue)
-        if is_ch_value:
-            return old_val == new_val
-        elif hasattr(old_val, "__dict__") and hasattr(new_val, "__dict__"):
-            return deep_eq(old_val.__dict__, new_val.__dict__, visiting)
-        elif isinstance(old_val, dict):
-            assert isinstance(new_val, dict)
-            for key in set(itertools.chain(old_val.keys(), *new_val.keys())):
-                if (key in old_val) ^ (key in new_val):
-                    return False
-                if not deep_eq(
-                    old_val.get(key, _UNEQUAL), new_val.get(key, _UNEQUAL), visiting
-                ):
-                    return False
-            return True
-        elif isinstance(old_val, Iterable):
-            assert isinstance(new_val, Sized)
-            if isinstance(old_val, Sized):
-                if len(old_val) != len(new_val):
-                    return False
-            assert isinstance(new_val, Iterable)
-            return all(
-                deep_eq(o, n, visiting)
-                for (o, n) in itertools.zip_longest(
-                    old_val, new_val, fillvalue=_UNEQUAL
-                )
-            )
-        elif type(old_val) is object:
-            # Plain object instances are close enough to equal for our purposes
-            return True
-        else:
-            # hopefully this is just ints, bools, etc
-            return old_val == new_val
-    finally:
-        visiting.remove(visit_key)
-
-
-class MessageGenerator:
-    def __init__(self, fn: Callable):
-        self.filename = ""
-        if hasattr(fn, "__code__"):
-            code_obj = fn.__code__
-            self.filename = code_obj.co_filename
-            self.start_lineno = code_obj.co_firstlineno
-            _, _, lines = sourcelines(fn)
-            self.end_lineno = self.start_lineno + len(lines)
-
-    def make(
-        self,
-        message_type: MessageType,
-        detail: str,
-        suggested_filename: Optional[str],
-        suggested_lineno: int,
-        tb: str,
-    ) -> AnalysisMessage:
-        if (
-            suggested_filename is not None
-            and (os.path.abspath(suggested_filename) == os.path.abspath(self.filename))
-            and (self.start_lineno <= suggested_lineno <= self.end_lineno)
-        ):
-            return AnalysisMessage(
-                message_type, detail, suggested_filename, suggested_lineno, 0, tb
-            )
-        else:
-            exprline = "<unknown>"
-            if suggested_filename is not None:
-                lines = linecache.getlines(suggested_filename)
-                try:
-                    exprline = lines[suggested_lineno - 1].strip()
-                except IndexError:
-                    pass
-            detail = f'"{exprline}" yields {detail}'
-            return AnalysisMessage(
-                message_type, detail, self.filename, self.start_lineno, 0, tb
-            )
-
-
 def make_counterexample_message(
     conditions: Conditions, args: BoundArguments, return_val: object = None
 ) -> str:
@@ -1457,11 +1516,11 @@ def attempt_call(
         detail = name_of_type(type(e)) + ": " + str(e)
         tb_desc = tb.format()
         frame_filename, frame_lineno = frame_summary_for_fn(conditions.src_fn, tb)
-        if not isinstance(e, NotDeterministic):
-            with ResumedTracing():
-                space.detach_path()
-            detail += " " + make_counterexample_message(conditions, original_args)
-        debug("exception while evaluating function body:", detail, tb_desc)
+        with ResumedTracing():
+            space.detach_path(e)
+        detail += " " + make_counterexample_message(conditions, original_args)
+        debug("exception while evaluating function body:", detail)
+        debug("exception traceback:", ch_stack(tb))
         return CallAnalysis(
             VerificationStatus.REFUTED,
             [
@@ -1481,10 +1540,8 @@ def attempt_call(
             and argname not in conditions.mutable_args
         ):
             old_val, new_val = original_args.arguments[argname], argval
-            # TODO: Do we really need custom equality here? Would love to drop that
-            # `deep_eq` function.
             with ResumedTracing():
-                if not deep_eq(old_val, new_val, set()):
+                if old_val != new_val:
                     space.detach_path()
                     detail = 'Argument "{}" is not marked as mutable, but changed from {} to {}'.format(
                         argname, old_val, new_val
@@ -1511,14 +1568,13 @@ def attempt_call(
     elif efilter.user_exc is not None:
         (e, tb) = efilter.user_exc
         detail = name_of_type(type(e)) + ": " + str(e)
-        if not isinstance(e, NotDeterministic):
-            with ResumedTracing():
-                space.detach_path()
-            detail += " " + make_counterexample_message(
-                conditions, original_args, __return__
-            )
+        with ResumedTracing():
+            space.detach_path(e)
+        detail += " " + make_counterexample_message(
+            conditions, original_args, __return__
+        )
         debug("exception while calling postcondition:", detail)
-        debug("exception traceback:", test_stack(tb))
+        debug("exception traceback:", ch_stack(tb))
         failures = [
             msg_gen.make(
                 MessageType.POST_ERR,
@@ -1570,7 +1626,7 @@ def _mutability_testing_hash(o: object) -> int:
 
 def is_deeply_immutable(o: object) -> bool:
     if not is_tracing():
-        raise CrosshairInternal("is_deeply_immutable must be run with tracing enabled")
+        raise CrossHairInternal("is_deeply_immutable must be run with tracing enabled")
     orig_modules = COMPOSITE_TRACER.get_modules()
     hash_intercept_module = PatchingModule({hash: _mutability_testing_hash})
     for module in reversed(orig_modules):