crosshair-tool 0.0.85__tar.gz → 0.0.86__tar.gz

{crosshair-tool-0.0.85 → crosshair_tool-0.0.86}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: crosshair-tool
-Version: 0.0.85
+Version: 0.0.86
 Summary: Analyze Python code for correctness using symbolic execution.
 Home-page: https://github.com/pschanely/CrossHair
 Author: Phillip Schanely
@@ -22,8 +22,43 @@ Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Provides-Extra: dev
 License-File: LICENSE
+Requires-Dist: packaging
+Requires-Dist: typing-inspect>=0.7.1
+Requires-Dist: typing_extensions>=3.10.0
+Requires-Dist: z3-solver>=4.13.0.0
+Requires-Dist: importlib_metadata>=4.0.0
+Requires-Dist: pygls>=1.0.0
+Requires-Dist: typeshed-client>=2.0.5
+Provides-Extra: dev
+Requires-Dist: autodocsumm<1,>=0.2.2; extra == "dev"
+Requires-Dist: black==22.3.0; extra == "dev"
+Requires-Dist: deal>=4.13.0; extra == "dev"
+Requires-Dist: icontract>=2.4.0; extra == "dev"
+Requires-Dist: isort==5.11.5; extra == "dev"
+Requires-Dist: mypy==0.990; extra == "dev"
+Requires-Dist: numpy==1.23.4; python_version < "3.12" and extra == "dev"
+Requires-Dist: numpy==1.26.0; (python_version >= "3.12" and python_version < "3.13") and extra == "dev"
+Requires-Dist: numpy==2.0.1; python_version >= "3.13" and extra == "dev"
+Requires-Dist: pre-commit~=2.20; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+Requires-Dist: setuptools; extra == "dev"
+Requires-Dist: sphinx>=3.4.3; extra == "dev"
+Requires-Dist: sphinx-rtd-theme>=0.5.1; extra == "dev"
+Requires-Dist: wheel; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 <img src="https://raw.githubusercontent.com/pschanely/CrossHair/main/doc/source/logo-gray.png" width="5%" align="left">
 

{crosshair-tool-0.0.85 → crosshair_tool-0.0.86}/crosshair/__init__.py

@@ -15,7 +15,7 @@ from crosshair.statespace import StateSpace
 from crosshair.tracers import NoTracing, ResumedTracing
 from crosshair.util import IgnoreAttempt, debug
 
-__version__ = "0.0.85"  # Do not forget to update in setup.py!
+__version__ = "0.0.86"  # Do not forget to update in setup.py!
 __author__ = "Phillip Schanely"
 __license__ = "MIT"
 __status__ = "Alpha"

{crosshair-tool-0.0.85 → crosshair_tool-0.0.86}/crosshair/libimpl/builtinslib.py

@@ -402,6 +402,10 @@ def crosshair_types_for_python_type(
     return _PYTYPE_TO_WRAPPER_TYPE.get(origin, ())
 
 
+def python_types_using_atomic_symbolics() -> Iterable[Type[AtomicSymbolicValue]]:
+    return _PYTYPE_TO_WRAPPER_TYPE.keys()
+
+
 class ModelingDirector:
     def __init__(self, *a) -> None:
         # Maps python type to the symbolic type we've chosen to represent it (on this iteration)
@@ -3488,10 +3492,6 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
                 otherpoints = [ord(ch) for ch in other]
                 with ResumedTracing():
                     return mypoints.__eq__(otherpoints)
-            elif isinstance(other, SeqBasedSymbolicStr):
-                with ResumedTracing():
-                    otherpoints = [ord(ch) for ch in other]
-                    return mypoints.__eq__(otherpoints)
             else:
                 return NotImplemented
 
@@ -3660,257 +3660,6 @@ class LazyIntSymbolicStr(AnySymbolicStr, CrossHairValue):
         return self._find(substr, start, end, from_right=True)
 
 
-class SeqBasedSymbolicStr(AtomicSymbolicValue, SymbolicSequence, AnySymbolicStr):
-    def __init__(self, smtvar: Union[str, z3.ExprRef], typ: Type = str):
-        assert typ == str
-        SymbolicValue.__init__(self, smtvar, typ)
-        self.item_pytype = str
-        if isinstance(smtvar, str):
-            # Constrain fresh strings to valid codepoints
-            space = context_statespace()
-            idxvar = z3.Int("idxvar" + space.uniq())
-            z3seq = self.var
-            space.add(
-                z3.ForAll(
-                    [idxvar], z3.And(0 <= z3seq[idxvar], z3seq[idxvar] <= maxunicode)
-                )
-            )
-
-    @classmethod
-    def _ch_smt_sort(cls) -> z3.SortRef:
-        return z3.SeqSort(z3.IntSort())
-
-    @classmethod
-    def _pytype(cls) -> Type:
-        return str
-
-    @classmethod
-    def _smt_promote_literal(cls, literal) -> Optional[z3.SortRef]:
-        if isinstance(literal, str):
-            if len(literal) <= 1:
-                if len(literal) == 0:
-                    return z3.Empty(z3.SeqSort(z3.IntSort()))
-                return z3.Unit(z3IntVal(ord(literal)))
-            return z3.Concat([z3.Unit(z3IntVal(ord(ch))) for ch in literal])
-        return None
-
-    def __ch_realize__(self) -> object:
-        codepoints = context_statespace().find_model_value(self.var)
-        return "".join(chr(x) for x in codepoints)
-
-    def __copy__(self):
-        return SeqBasedSymbolicStr(self.var)
-
-    def __hash__(self):
-        return hash(self.__str__())
-
-    @staticmethod
-    def _concat_strings(
-        a: Union[str, "SeqBasedSymbolicStr"], b: Union[str, "SeqBasedSymbolicStr"]
-    ) -> Union[str, "SeqBasedSymbolicStr"]:
-        assert not is_tracing()
-        # Assumes at least one argument is symbolic and not tracing
-        if isinstance(a, SeqBasedSymbolicStr) and isinstance(b, SeqBasedSymbolicStr):
-            return SeqBasedSymbolicStr(a.var + b.var)
-        elif isinstance(a, str) and isinstance(b, SeqBasedSymbolicStr):
-            return SeqBasedSymbolicStr(
-                SeqBasedSymbolicStr._coerce_to_smt_sort(a) + b.var
-            )
-        else:
-            assert isinstance(a, SeqBasedSymbolicStr)
-            assert isinstance(b, str)
-            return SeqBasedSymbolicStr(
-                a.var + SeqBasedSymbolicStr._coerce_to_smt_sort(b)
-            )
-
-    def __add__(self, other):
-        with NoTracing():
-            if isinstance(other, (SeqBasedSymbolicStr, str)):
-                return SeqBasedSymbolicStr._concat_strings(self, other)
-            if isinstance(other, AnySymbolicStr):
-                return NotImplemented
-            raise TypeError
-
-    def __radd__(self, other):
-        with NoTracing():
-            if isinstance(other, (SeqBasedSymbolicStr, str)):
-                return SeqBasedSymbolicStr._concat_strings(other, self)
-            if isinstance(other, AnySymbolicStr):
-                return NotImplemented
-            raise TypeError
-
-    def __mul__(self, other):
-        if isinstance(other, Integral):
-            if other <= 1:
-                return self if other == 1 else ""
-            # Note that in SymbolicInt, we attempt string multiplication via regex.
-            # Z3 cannot do much with a symbolic regex, so we case-split on
-            # the repetition count.
-            return SeqBasedSymbolicStr(z3.Concat(*[self.var for _ in range(other)]))
-        return NotImplemented
-
-    __rmul__ = __mul__
-
-    def __mod__(self, other):
-        return self.__str__() % realize(other)
-
-    def __contains__(self, other):
-        with NoTracing():
-            forced = force_to_smt_sort(other, SeqBasedSymbolicStr)
-            return SymbolicBool(z3.Contains(self.var, forced))
-
-    def __getitem__(self, i: Union[int, slice]):
-        with NoTracing():
-            idx_or_pair = process_slice_vs_symbolic_len(
-                context_statespace(), i, z3.Length(self.var)
-            )
-            if isinstance(idx_or_pair, tuple):
-                (start, stop) = idx_or_pair
-                smt_result = z3.Extract(self.var, start, stop - start)
-            else:
-                smt_result = z3.Unit(self.var[idx_or_pair])
-            return SeqBasedSymbolicStr(smt_result)
-
-    def endswith(self, substr):
-        with NoTracing():
-            smt_substr = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-            return SymbolicBool(z3.SuffixOf(smt_substr, self.var))
-
-    def find(self, substr, start=None, end=None):
-        if not isinstance(substr, str):
-            raise TypeError
-        with NoTracing():
-            space = context_statespace()
-            smt_my_len = z3.Length(self.var)
-            if start is None and end is None:
-                smt_start = z3IntVal(0)
-                smt_end = smt_my_len
-                smt_str = self.var
-                if len(substr) == 0:
-                    return 0
-            else:
-                (smt_start, smt_end) = flip_slice_vs_symbolic_len(
-                    space, slice(start, end, None), smt_my_len
-                )
-                if len(substr) == 0:
-                    # Add oddity of CPython. We can find the empty string when over-slicing
-                    # off the left side of the string, but not off the right:
-                    # ''.find('', 3, 4) == -1
-                    # ''.find('', -4, -3) == 0
-                    if space.smt_fork(smt_start > smt_my_len):
-                        return -1
-                    elif space.smt_fork(smt_start > 0):
-                        return SymbolicInt(smt_start)
-                    else:
-                        return 0
-                (smt_start, smt_end) = clip_range_to_symbolic_len(
-                    space, smt_start, smt_end, smt_my_len
-                )
-                smt_str = z3.SubString(self.var, smt_start, smt_end - smt_start)
-
-            smt_sub = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-            if space.smt_fork(z3.Contains(smt_str, smt_sub)):
-                return SymbolicInt(z3.IndexOf(smt_str, smt_sub, 0) + smt_start)
-            else:
-                return -1
-
-    def partition(self, sep: str):
-        if not isinstance(sep, str):
-            raise TypeError
-        if len(sep) == 0:
-            raise ValueError
-        with NoTracing():
-            space = context_statespace()
-            smt_str = self.var
-            smt_sep = force_to_smt_sort(sep, SeqBasedSymbolicStr)
-            if space.smt_fork(z3.Contains(smt_str, smt_sep)):
-                uniq = space.uniq()
-                # Divide my contents into 4 concatenated parts:
-                prefix = SeqBasedSymbolicStr(f"prefix{uniq}")
-                match1 = SeqBasedSymbolicStr(
-                    f"match1{uniq}"
-                )  # the first character of the match
-                match_tail = SeqBasedSymbolicStr(f"match_tail{uniq}")
-                suffix = SeqBasedSymbolicStr(f"suffix{uniq}")
-                space.add(z3.Length(match1.var) == 1)
-                space.add(smt_sep == z3.Concat(match1.var, match_tail.var))
-                space.add(smt_str == z3.Concat(prefix.var, smt_sep, suffix.var))
-                space.add(
-                    z3.Not(z3.Contains(z3.Concat(match_tail.var, suffix.var), smt_sep))
-                )
-                return (prefix, sep, suffix)
-            else:
-                return (self, "", "")
-
-    def rfind(self, substr, start=None, end=None) -> Union[int, SymbolicInt]:
-        if not isinstance(substr, str):
-            raise TypeError
-        with NoTracing():
-            space = context_statespace()
-            smt_my_len = z3.Length(self.var)
-            if start is None and end is None:
-                smt_start = z3IntVal(0)
-                smt_end = smt_my_len
-                smt_str = self.var
-                if len(substr) == 0:
-                    return SymbolicInt(smt_my_len)
-            else:
-                (smt_start, smt_end) = flip_slice_vs_symbolic_len(
-                    space, slice(start, end, None), smt_my_len
-                )
-                if len(substr) == 0:
-                    # Add oddity of CPython. We can find the empty string when over-slicing
-                    # off the left side of the string, but not off the right:
-                    # ''.find('', 3, 4) == -1
-                    # ''.find('', -4, -3) == 0
-                    if space.smt_fork(smt_start > smt_my_len):
-                        return -1
-                    elif space.smt_fork(smt_end < 0):
-                        return 0
-                    elif space.smt_fork(smt_end < smt_my_len):
-                        return SymbolicInt(smt_end)
-                    else:
-                        return SymbolicInt(smt_my_len)
-                (smt_start, smt_end) = clip_range_to_symbolic_len(
-                    space, smt_start, smt_end, smt_my_len
-                )
-                smt_str = z3.SubString(self.var, smt_start, smt_end - smt_start)
-            smt_sub = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-            if space.smt_fork(z3.Contains(smt_str, smt_sub)):
-                uniq = space.uniq()
-                # Divide my contents into 4 concatenated parts:
-                prefix = SeqBasedSymbolicStr(f"prefix{uniq}")
-                match1 = SeqBasedSymbolicStr(f"match1{uniq}")
-                match_tail = SeqBasedSymbolicStr(f"match_tail{uniq}")
-                suffix = SeqBasedSymbolicStr(f"suffix{uniq}")
-                space.add(z3.Length(match1.var) == 1)
-                space.add(smt_sub == z3.Concat(match1.var, match_tail.var))
-                space.add(smt_str == z3.Concat(prefix.var, smt_sub, suffix.var))
-                space.add(
-                    z3.Not(z3.Contains(z3.Concat(match_tail.var, suffix.var), smt_sub))
-                )
-                return SymbolicInt(smt_start + z3.Length(prefix.var))
-            else:
-                return -1
-
-    def rpartition(self, sep: str):
-        result = self.rsplit(sep, maxsplit=1)
-        if len(result) == 1:
-            return ("", "", self)
-        elif len(result) == 2:
-            return (result[0], sep, result[1])
-
-    def startswith(self, substr, start=None, end=None):
-        if isinstance(substr, tuple):
-            return any(self.startswith(s, start, end) for s in substr)
-        smt_substr = force_to_smt_sort(substr, SeqBasedSymbolicStr)
-        if start is not None or end is not None:
-            # TODO: "".startswith("", 1) should be False, not True
-            return self[start:end].startswith(substr)
-        with NoTracing():
-            return SymbolicBool(z3.PrefixOf(smt_substr, self.var))
-
-
 def buffer_to_byte_seq(obj: object) -> Optional[Sequence[int]]:
     if isinstance(obj, (bytes, bytearray)):
         return list(obj)
@@ -4822,11 +4571,6 @@ def _ord(c: str) -> int:
     with NoTracing():
         if isinstance(c, LazyIntSymbolicStr):
             return c._codepoints[0]
-        elif isinstance(c, SeqBasedSymbolicStr):
-            space = context_statespace()
-            ret = SymbolicInt("ord" + space.uniq())
-            space.add(c.var == z3.Unit(ret.var))
-            return ret
     return ord(realize(c))
 
 

{crosshair-tool-0.0.85 → crosshair_tool-0.0.86}/crosshair/libimpl/builtinslib_test.py

@@ -2117,7 +2117,7 @@ def test_dict___bool___ok() -> None:
     check_states(f, CONFIRMED)
 
 
-def test_dict___iter__() -> None:
+def test_dict___iter___fail() -> None:
     def f(a: Dict[int, str]) -> List[int]:
         """
         post[a]: 5 in _

{crosshair-tool-0.0.85 → crosshair_tool-0.0.86}/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-tool-0.0.85 → crosshair_tool-0.0.86}/crosshair/opcode_intercept.py

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