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

crosshair/simplestructs.py

@@ -20,9 +20,15 @@ from typing import (
     Union,
 )
 
-from crosshair.core import CrossHairValue, deep_realize
-from crosshair.tracers import NoTracing, tracing_iter
-from crosshair.util import is_hashable, is_iterable, name_of_type
+from crosshair.core import deep_realize
+from crosshair.tracers import NoTracing, ResumedTracing, tracing_iter
+from crosshair.util import (
+    CrossHairValue,
+    assert_tracing,
+    is_hashable,
+    is_iterable,
+    name_of_type,
+)
 
 
 class MapBase(collections.abc.MutableMapping):
@@ -32,10 +38,10 @@ class MapBase(collections.abc.MutableMapping):
             return NotImplemented
         if len(self) != len(other):
             return False
-        for (k, self_value) in self.items():
+        for k, self_value in self.items():
             found = False
             # We do a slow nested loop search because we don't want to hash the key.
-            for (other_key, other_value) in other.items():
+            for other_key, other_value in other.items():
                 if other_key != k:
                     continue
                 if self_value == other_value:
@@ -53,6 +59,16 @@ class MapBase(collections.abc.MutableMapping):
     def __ch_pytype__(self):
         return dict
 
+    def __ch_realize__(self):
+        memo = {}
+        return {deep_realize(k, memo): v for k, v in tracing_iter(self.items())}
+
+    def __ch_deep_realize__(self, memo):
+        return {
+            deep_realize(k, memo): deep_realize(v, memo)
+            for k, v in tracing_iter(self.items())
+        }
+
     def __repr__(self):
         contents = ", ".join(f"{repr(k)}: {repr(v)}" for (k, v) in self.items())
         return "{" + contents + "}"
@@ -106,8 +122,10 @@ class SimpleDict(MapBase):
     def __getitem__(self, key, default=_MISSING):
         if not is_hashable(key):
             raise TypeError("unhashable type")
-        for (k, v) in self.contents_:
-            if k == key:
+        for k, v in self.contents_:
+            # Note that the identity check below is not just an optimization;
+            # it is required to implement the semantics of NaN dict keys
+            if k is key or k == key:
                 return v
         if default is _MISSING:
             raise KeyError
@@ -116,7 +134,7 @@ class SimpleDict(MapBase):
     def __setitem__(self, key, value):
         if not is_hashable(key):
             raise TypeError("unhashable type")
-        for (i, (k, v)) in enumerate(self.contents_):
+        for i, (k, v) in enumerate(self.contents_):
             if k == key:
                 self.contents_[i] = (k, value)
                 return
@@ -125,7 +143,7 @@ class SimpleDict(MapBase):
     def __delitem__(self, key):
         if not is_hashable(key):
             raise TypeError("unhashable type")
-        for (i, (k, v)) in enumerate(self.contents_):
+        for i, (k, v) in enumerate(self.contents_):
             if k == key:
                 del self.contents_[i]
                 return
@@ -143,9 +161,6 @@ class SimpleDict(MapBase):
     def __len__(self):
         return self.contents_.__len__()
 
-    def items(self):
-        return self.contents_
-
     def popitem(self):
         if not self.contents_:
             raise KeyError
@@ -478,9 +493,11 @@ class SequenceConcatenation(collections.abc.Sequence, SeqBase):
                     return second.__getitem__(
                         slice(
                             i.start - firstlen,
-                            i.stop
-                            if i.stop is None or i.stop < 0
-                            else i.stop - firstlen,
+                            (
+                                i.stop
+                                if i.stop is None or i.stop < 0
+                                else i.stop - firstlen
+                            ),
                             i.step,
                         )
                     )
@@ -728,14 +745,23 @@ class ShellMutableSequence(collections.abc.MutableSequence, SeqBase):
 
 
 AbcSet = collections.abc.Set
+AbcMutableSet = collections.abc.MutableSet
 
 
 def _force_arg_to_set(x: object) -> AbcSet:
-    if isinstance(x, AbcSet):
-        return x
-    if is_iterable(x):
-        return LinearSet.check_unique_and_create(x)
-    raise TypeError
+    with NoTracing():
+        if isinstance(x, AbcSet):
+            while isinstance(x, ShellMutableSet):
+                x = x._inner
+            if isinstance(x, AbcMutableSet):
+                # Already known to have unique elements:
+                return LinearSet(list(tracing_iter(x)))
+            elif isinstance(x, (frozenset, FrozenSetBase)):
+                return x  # Immutable set
+        if is_iterable(x):
+            with ResumedTracing():
+                return LinearSet.check_unique_and_create(x)
+        raise TypeError
 
 
 class SetBase(CrossHairValue):
@@ -750,9 +776,6 @@ class SetBase(CrossHairValue):
     def __repr__(self):
         return deep_realize(self).__repr__()
 
-    def __hash__(self):
-        return hash(set(self))
-
     def __and__(self, x):
         if not isinstance(x, AbcSet):
             return NotImplemented
@@ -813,7 +836,34 @@ class SetBase(CrossHairValue):
         return self
 
 
-class SingletonSet(SetBase, AbcSet):
+class FrozenSetBase(SetBase, AbcSet):
+    def __ch_realize__(self):
+        # We are going to have to hash all of our contents,
+        # so just realize everything.
+        return self.__ch_deep_realize__({})
+
+    @assert_tracing(False)
+    def __ch_deep_realize__(self, memo):
+        contents = []
+        for item in tracing_iter(self):
+            contents.append(deep_realize(item, memo))
+        # TODO: This fails to preserve the iteration order;
+        # should we do something about that?:
+        return frozenset(contents)
+
+    def __ch_pytype__(self):
+        return frozenset
+
+    @classmethod
+    def _from_iterable(cls, it):
+        # overrides collections.abc.Set's version
+        return LinearSet.check_unique_and_create(it)
+
+    def __hash__(self):
+        return hash(deep_realize(self))
+
+
+class SingletonSet(FrozenSetBase):
     # Primarily this exists to avoid hashing values.
     # TODO: should we fold uses of this into LinearSet, below?
 
@@ -830,9 +880,7 @@ class SingletonSet(SetBase, AbcSet):
         return 1
 
 
-class EmptySet(SetBase, AbcSet):
-    # Primarily this exists to avoid hashing values.
-
+class EmptySet(FrozenSetBase):
     def __contains__(self, x):
         if not is_hashable(x):
             raise TypeError
@@ -846,7 +894,7 @@ class EmptySet(SetBase, AbcSet):
         return 0
 
 
-class LinearSet(SetBase, AbcSet):
+class LinearSet(FrozenSetBase):
     # Primarily this exists to avoid hashing values.
     # Presumes that its arguments are already unique.
 
@@ -881,7 +929,7 @@ class LinearSet(SetBase, AbcSet):
         return len(self._items)
 
 
-class LazySetCombination(SetBase, AbcSet):
+class LazySetCombination(FrozenSetBase):
     """
     Provide a view over two sets and a logical operation in-between.
 
@@ -927,23 +975,29 @@ class LazySetCombination(SetBase, AbcSet):
         return sum(1 for i in self.__iter__())
 
 
-class ShellMutableSet(SetBase, collections.abc.MutableSet):
+class ShellMutableSet(SetBase, AbcMutableSet):
     """
-    Provide a view over an immutable set.
+    Provide a mutable view over an immutable set.
 
-    The view give the immutable set mutating operations that replace the underlying
+    The mutating operations simply replace the underlying
     data structure entirely.
     This set also attempts to preserve insertion order of the set,
     assuming the underlying set(s) do so as well.
     """
 
-    _inner: Set
+    _inner: Union[frozenset, FrozenSetBase]
 
-    def __init__(self, inner=EmptySet()):
-        if isinstance(inner, AbcSet):
+    @assert_tracing(False)
+    def __init__(self, inner: Iterable = EmptySet()):
+        if isinstance(inner, FrozenSetBase):
             self._inner = inner
+        elif isinstance(inner, frozenset):
+            self._inner = LinearSet(inner)
+        elif isinstance(inner, set):
+            self._inner = LinearSet(frozenset(inner))
         elif is_iterable(inner):
-            self._inner = LinearSet.check_unique_and_create(inner)
+            with ResumedTracing():
+                self._inner = LinearSet.check_unique_and_create(inner)
         else:
             raise TypeError
 
@@ -989,7 +1043,7 @@ class ShellMutableSet(SetBase, collections.abc.MutableSet):
     # mutation operations
     def add(self, x):
         if not is_hashable(x):
-            raise TypeError("unhashable type")
+            raise TypeError(f"unhashable type: '{name_of_type(type(x))}'")
         self.__ior__(SingletonSet(x))
 
     def clear(self):
@@ -1000,7 +1054,7 @@ class ShellMutableSet(SetBase, collections.abc.MutableSet):
 
     def discard(self, x):
         if not is_hashable(x):
-            raise TypeError("unhashable type")
+            raise TypeError(f"unhashable type: '{name_of_type(type(x))}'")
         self.__isub__(SingletonSet(x))
 
     def intersection_update(self, x):
@@ -1023,74 +1077,89 @@ class ShellMutableSet(SetBase, collections.abc.MutableSet):
         self._inner = self._inner.symmetric_difference(x)
 
     def update(self, *iterables):
-        additions = ShellMutableSet([value for itr in iterables for value in iter(itr)])
-        self._inner = LazySetCombination(operator.or_, self._inner, additions)
+        for itr in iterables:
+            additions = _force_arg_to_set(itr)
+            self._inner = LazySetCombination(operator.or_, self._inner, additions)
 
     def __or__(self, x):
-        if not isinstance(x, AbcSet):
-            return NotImplemented
-        return ShellMutableSet(LazySetCombination(operator.or_, self._inner, x))
+        with NoTracing():
+            if not isinstance(x, AbcSet):
+                return NotImplemented
+            return ShellMutableSet(
+                LazySetCombination(operator.or_, self._inner, _force_arg_to_set(x))
+            )
 
     __ror__ = __or__
 
     def __and__(self, x):
-        if not isinstance(x, AbcSet):
-            return NotImplemented
-        return ShellMutableSet(LazySetCombination(operator.and_, self._inner, x))
+        with NoTracing():
+            if not isinstance(x, AbcSet):
+                return NotImplemented
+            return ShellMutableSet(
+                LazySetCombination(operator.and_, self._inner, _force_arg_to_set(x))
+            )
 
     __rand__ = __and__
 
     def __xor__(self, x):
-        if not isinstance(x, AbcSet):
-            return NotImplemented
-        return ShellMutableSet(LazySetCombination(operator.xor, self._inner, x))
+        with NoTracing():
+            if not isinstance(x, AbcSet):
+                return NotImplemented
+            return ShellMutableSet(
+                LazySetCombination(operator.xor, self._inner, _force_arg_to_set(x))
+            )
 
     __rxor__ = __xor__
 
     def __sub__(self, x):
-        if not isinstance(x, AbcSet):
-            return NotImplemented
-        return ShellMutableSet(
-            LazySetCombination(lambda x, y: (x and not y), self._inner, x)
-        )
+        with NoTracing():
+            if not isinstance(x, AbcSet):
+                return NotImplemented
+            # TODO: why not lazy set combination here?
+            return ShellMutableSet(
+                LazySetCombination(lambda x, y: (x and not y), self._inner, x)
+            )
 
     def __rsub__(self, x):
-        if not isinstance(x, AbcSet):
-            return NotImplemented
-        return ShellMutableSet(
-            LazySetCombination(lambda x, y: (y and not x), self._inner, x)
-        )
+        with NoTracing():
+            if not isinstance(x, AbcSet):
+                return NotImplemented
+            return ShellMutableSet(
+                LazySetCombination(lambda x, y: (y and not x), self._inner, x)
+            )
 
     def __ior__(self, x):
-        if not isinstance(x, AbcSet):
-            return NotImplemented
-        self._inner = LazySetCombination(operator.or_, self._inner, x)
-        return self
+        with NoTracing():
+            if not isinstance(x, AbcSet):
+                return NotImplemented
+            self._inner = LazySetCombination(
+                operator.or_, self._inner, _force_arg_to_set(x)
+            )
+            return self
 
     def __iand__(self, x):
-        if not isinstance(x, AbcSet):
-            return NotImplemented
-        self._inner = LazySetCombination(operator.and_, self._inner, x)
-        return self
+        with NoTracing():
+            if not isinstance(x, AbcSet):
+                return NotImplemented
+            self._inner = LazySetCombination(
+                operator.and_, self._inner, _force_arg_to_set(x)
+            )
+            return self
 
     def __ixor__(self, x):
-        if not isinstance(x, AbcSet):
-            return NotImplemented
-        self._inner = LazySetCombination(operator.xor, self._inner, x)
-        return self
+        with NoTracing():
+            if not isinstance(x, AbcSet):
+                return NotImplemented
+            self._inner = LazySetCombination(
+                operator.xor, self._inner, _force_arg_to_set(x)
+            )
+            return self
 
     def __isub__(self, x):
-        if not isinstance(x, AbcSet):
-            return NotImplemented
-        self._inner = LazySetCombination(lambda x, y: (x and not y), self._inner, x)
-        return self
-
-
-def _test_seq_concat(seq: SequenceConcatenation, i: slice):
-    """
-    Test that slices of SequenceConcatenations are correct.
-
-    raises: IndexError
-    post: _[0] == _[1]
-    """
-    return (seq[i], (seq._first + seq._second)[i])  # type: ignore
+        with NoTracing():
+            if not isinstance(x, AbcSet):
+                return NotImplemented
+            self._inner = LazySetCombination(
+                lambda x, y: (x and not y), self._inner, _force_arg_to_set(x)
+            )
+            return self

crosshair/simplestructs_test.py

@@ -3,7 +3,7 @@ import sys
 
 import pytest
 
-from crosshair.core import deep_realize
+from crosshair.core import deep_realize, realize
 from crosshair.simplestructs import (
     LazySetCombination,
     SequenceConcatenation,
@@ -87,6 +87,20 @@ def test_LazySetCombination_xor() -> None:
     assert 5 in s
 
 
+def test_ShellMutableDict_realize() -> None:
+    shell = ShellMutableMap({1: ShellMutableMap({2: 3})})
+    realized = realize(shell)
+    assert isinstance(realized, dict)
+    assert isinstance(realized[1], ShellMutableMap)
+
+
+def test_ShellMutableDict_deep_realize() -> None:
+    shell = ShellMutableMap({1: ShellMutableMap({2: 3})})
+    realized = deep_realize(shell)
+    assert isinstance(realized, dict)
+    assert isinstance(realized[1], dict)
+
+
 def test_ShellMutableSet_deepcopy() -> None:
     ls = ["0", "1", "2", "3"]
     shell = ShellMutableSet(ls)
@@ -223,7 +237,7 @@ def test_ShellMutableSet_errors() -> None:
     with pytest.raises(KeyError):
         ShellMutableSet([]).pop()
     with pytest.raises(TypeError):
-        ShellMutableSet(4)
+        ShellMutableSet(4)  # type: ignore
 
 
 @pytest.mark.parametrize("start", [-3, -1, 0, 1, 3, None])

crosshair/smtlib.py

@@ -0,0 +1,24 @@
+import math
+import re
+import struct
+
+_SL2_PARSE_FLOAT_RE = re.compile(r"\(fp #(b\d+) #(b\d+) #(x.+)\)")
+LITERAL_CONSTS = {
+    "(_ -zero 11 53)": -0.0,
+    "(_ +zero 11 53)": 0.0,
+    "(_ -oo 11 53)": -math.inf,
+    "(_ +oo 11 53)": math.inf,
+    "(_ NaN 11 53)": math.nan,
+}
+
+
+def parse_smtlib_literal(input: str):
+    literal_const = LITERAL_CONSTS.get(input, None)
+    if literal_const is not None:
+        return literal_const
+    match = _SL2_PARSE_FLOAT_RE.fullmatch(input)
+    if match:
+        sign, exp, significand = (int("0" + g, base=0) for g in match.groups())
+        return struct.unpack(
+            "d", struct.pack("Q", sign << 63 | exp << 52 | significand)
+        )[0]

crosshair/smtlib_test.py

@@ -0,0 +1,14 @@
+import math
+
+import z3  # type: ignore
+
+from crosshair.smtlib import parse_smtlib_literal
+
+
+def test_parse_smtlib_literal():
+    assert parse_smtlib_literal(z3.FPVal(1.23, z3.Float64).sexpr()) == 1.23
+    assert math.isnan(parse_smtlib_literal(z3.FPVal(math.nan, z3.Float64).sexpr()))
+    assert parse_smtlib_literal(z3.FPVal(-math.inf, z3.Float64).sexpr()) <= -math.inf
+    negzero = parse_smtlib_literal(z3.FPVal(-0.0, z3.Float64).sexpr())
+    assert negzero == 0
+    assert math.copysign(42, negzero) == -42