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

crosshair/libimpl/relib_test.py

@@ -4,14 +4,15 @@ from typing import Optional
 
 import pytest
 
-from crosshair.core import deep_realize
+from crosshair import ResumedTracing
+from crosshair.core import deep_realize, proxy_for_type
 from crosshair.core_and_libs import NoTracing, standalone_statespace
-from crosshair.libimpl.builtinslib import LazyIntSymbolicStr
-from crosshair.libimpl.relib import _BACKREF_RE, _match_pattern
+from crosshair.libimpl.builtinslib import LazyIntSymbolicStr, SymbolicBytes
+from crosshair.libimpl.relib import _BACKREF_STR_RE, _match_pattern
 from crosshair.options import AnalysisOptionSet
 from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL, MessageType
 from crosshair.test_util import check_states
-from crosshair.util import CrosshairInternal, set_debug
+from crosshair.util import CrossHairInternal
 
 
 def eval_regex(re_string, flags, test_string, offset, endpos=None):
@@ -374,17 +375,17 @@ def test_lookbehind() -> None:
 
 
 def test_backref_re():
-    assert _BACKREF_RE.fullmatch(r"\1").group("num") == "1"
-    assert _BACKREF_RE.fullmatch(r"ab\1cd").group("num") == "1"
-    assert _BACKREF_RE.fullmatch(r"$%^ \g<_cat> &*").group("named") == "_cat"
-    assert _BACKREF_RE.fullmatch(r"\g< cat>").group("namedother") == " cat"
-    assert _BACKREF_RE.fullmatch(r"\g<0>").group("namednum") == "0"
-    assert _BACKREF_RE.fullmatch(r"\g<+100>").group("namednum") == "+100"
-    assert _BACKREF_RE.fullmatch(r"\1 foo \2").group("num") == "1"
+    assert _BACKREF_STR_RE.fullmatch(r"\1").group("num") == "1"
+    assert _BACKREF_STR_RE.fullmatch(r"ab\1cd").group("num") == "1"
+    assert _BACKREF_STR_RE.fullmatch(r"$%^ \g<_cat> &*").group("named") == "_cat"
+    assert _BACKREF_STR_RE.fullmatch(r"\g< cat>").group("namedother") == " cat"
+    assert _BACKREF_STR_RE.fullmatch(r"\g<0>").group("namednum") == "0"
+    assert _BACKREF_STR_RE.fullmatch(r"\g<+100>").group("namednum") == "+100"
+    assert _BACKREF_STR_RE.fullmatch(r"\1 foo \2").group("num") == "1"
 
     # "\g<0>" is OK; "\0" is not:
-    assert _BACKREF_RE.fullmatch(r"\g<0>")
-    assert not _BACKREF_RE.fullmatch(r"\0")
+    assert _BACKREF_STR_RE.fullmatch(r"\g<0>")
+    assert not _BACKREF_STR_RE.fullmatch(r"\0")
 
 
 def test_template_expansion():
@@ -422,9 +423,71 @@ def test_charmatch_literal_does_not_fork():
             s = LazyIntSymbolicStr(list(map(ord, "abaa")))
 
             def explode(*a, **kw):
-                raise CrosshairInternal
+                raise CrossHairInternal
 
             space.smt_fork = explode
         match = letters.match(s)
         assert match
         assert match.group(0) == "a"
+
+
+def test_symbolic_offset():
+    _all_zeros = re.compile("0*$")
+    with standalone_statespace as space:
+        with NoTracing():
+            string = LazyIntSymbolicStr(list(map(ord, "21000")))
+            offset = proxy_for_type(int, "offset")
+            endpos = proxy_for_type(int, "endpos")
+        space.add(offset == 2)
+        space.add(endpos == 5)
+        assert _all_zeros.match(string, offset)
+        assert not _all_zeros.match(string, offset - 1)
+        assert not _all_zeros.match(string + "1", offset)
+        assert _all_zeros.match(string + "1", offset, endpos)
+        assert not _all_zeros.match(string + "1", offset, endpos + 1)
+
+
+@pytest.mark.parametrize(
+    "patt_char,match_char",
+    [
+        ("ß", "ẞ"),
+        ("ẞ", "ß"),
+        ("İ", "i"),
+        ("i", "İ"),
+        ("Ⓐ", "ⓐ"),
+        ("ⓐ", "Ⓐ"),
+    ],
+)
+def test_ignorecase_matches(space, patt_char, match_char):
+    pattern = re.compile(patt_char, re.IGNORECASE)
+    # sanity check that regular python does what we expect:
+    assert pattern.fullmatch(match_char)
+    symbolic_match_char = LazyIntSymbolicStr(list(map(ord, match_char)))
+    with ResumedTracing():
+        assert pattern.fullmatch(symbolic_match_char)
+
+
+@pytest.mark.parametrize(
+    "patt_char,match_char",
+    [
+        ("a", "ⓐ"),
+        ("ß".upper(), "ß"),
+        ("ß", "ß".upper()),
+        ("İ".lower(), "İ"),
+        ("İ", "İ".lower()),
+    ],
+)
+def test_ignorecase_nonmatches(space, patt_char, match_char):
+    pattern = re.compile(patt_char, re.IGNORECASE)
+    # sanity check that regular python does what we expect:
+    assert not pattern.fullmatch(match_char)
+    symbolic_match_char = LazyIntSymbolicStr(list(map(ord, match_char)))
+    with ResumedTracing():
+        assert not pattern.fullmatch(symbolic_match_char)
+
+
+def test_bytes_based_pattern(space):
+    string = SymbolicBytes(b"abbc")
+    with ResumedTracing():
+        assert re.fullmatch(b"ab+c", string)
+        assert [m.span() for m in re.finditer(b"b", string)] == [(1, 2), (2, 3)]

crosshair/libimpl/timelib.py

@@ -1,26 +1,45 @@
 import time as real_time
 from inspect import Signature
-from typing import Any, Callable
+from math import isfinite
+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(
@@ -30,21 +49,24 @@ def make_registrations():
     )
     register_contract(
         real_time.monotonic,
-        post=lambda __return__: _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__: _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 CANNOT_CONFIRM, CONFIRMED, POST_FAIL, MessageType
+from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL
 from crosshair.test_util import check_states
 
 
@@ -60,7 +60,7 @@ def test_monotonic_confirm():
         start = time.monotonic()
         return time.monotonic() - start
 
-    check_states(f, CANNOT_CONFIRM)
+    check_states(f, CONFIRMED)
 
 
 def test_monotonic_ns():
@@ -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.py

@@ -0,0 +1,15 @@
+from types import MappingProxyType
+from typing import Any, Dict
+
+from crosshair.core import register_patch, register_type
+
+
+def _repr(map: MappingProxyType):
+    if not isinstance(map, MappingProxyType):
+        raise TypeError
+    return f"mappingproxy({repr(dict(map))})"
+
+
+def make_registrations():
+    register_type(MappingProxyType, lambda p, kt=Any, vt=Any: MappingProxyType(p(Dict[kt, vt])))  # type: ignore
+    register_patch(MappingProxyType.__repr__, _repr)

crosshair/libimpl/typeslib_test.py

@@ -0,0 +1,36 @@
+import sys
+from types import MappingProxyType
+from typing import Dict
+
+import pytest
+
+from crosshair import ResumedTracing
+from crosshair.core import deep_realize, proxy_for_type
+from crosshair.libimpl.builtinslib import SymbolicInt
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9), reason="MappingProxyType not subscriptable in 3.8"
+)
+def test_mappingproxy_repr(space):
+    d = proxy_for_type(MappingProxyType[int, int], "d")
+    with ResumedTracing():
+        assert repr(d).startswith("mappingproxy(")
+
+
+def test_mappingproxy_deep_realize(space):
+    inner = proxy_for_type(Dict[int, int], "inner")
+    with ResumedTracing():
+        space.add(inner._inner.__len__() == 1)
+        key = next(iter(inner.keys()))
+    assert type(key) is SymbolicInt
+    orig = MappingProxyType(inner)
+    assert type(orig) is MappingProxyType
+    copy = deep_realize(orig)
+    assert type(copy) is MappingProxyType
+    with ResumedTracing():
+        val_from_orig = orig[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/libimpl/unicodedatalib_test.py

@@ -11,7 +11,7 @@ def test_numeric():
     with standalone_statespace as space:
         with NoTracing():
             fourstr = LazyIntSymbolicStr(list(map(ord, "4")))
-            halfstr = LazyIntSymbolicStr(list(map(ord, "\u00BD")))  # (1/2 character)
+            halfstr = LazyIntSymbolicStr(list(map(ord, "\u00bd")))  # (1/2 character)
         four = unicodedata.numeric(fourstr)
         half = unicodedata.numeric(halfstr)
         assert type(four) is float
@@ -22,7 +22,7 @@ def test_numeric():
 def test_decimal():
     with standalone_statespace as space:
         with NoTracing():
-            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0E54")))  # (Thai numerial 4)
+            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0e54")))  # (Thai numerial 4)
             super4 = LazyIntSymbolicStr(list(map(ord, "\u2074")))  # (superscript 4)
         four = unicodedata.decimal(thai4)
         assert type(four) is int
@@ -34,7 +34,7 @@ def test_decimal():
 def test_digit():
     with standalone_statespace as space:
         with NoTracing():
-            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0E54")))  # (Thai numerial 4)
+            thai4 = LazyIntSymbolicStr(list(map(ord, "\u0e54")))  # (Thai numerial 4)
             super4 = LazyIntSymbolicStr(list(map(ord, "\u2074")))  # (superscript 4)
         four = unicodedata.digit(thai4)
         assert type(four) is int

crosshair/libimpl/weakreflib.py

@@ -0,0 +1,13 @@
+from weakref import ref
+
+from crosshair.core import register_patch
+
+
+def _ref_call(r):
+    if not isinstance(r, ref):
+        raise TypeError
+    return None
+
+
+def make_registrations():
+    register_patch(ref.__call__, _ref_call)

crosshair/libimpl/weakreflib_test.py

@@ -0,0 +1,69 @@
+from weakref import WeakKeyDictionary, WeakSet, WeakValueDictionary, proxy, ref
+
+import pytest
+
+from crosshair.tracers import ResumedTracing
+
+
+class Thing:
+    x: int = 0
+
+
+def test_weakref(space):
+    thing1 = Thing()
+    assert ref(thing1)() is thing1
+    with ResumedTracing():
+        assert ref(thing1)() is None
+
+
+def test_weakref_WeakKeyDictionary(space):
+    d = WeakKeyDictionary()
+    thing1 = Thing()
+    thing2 = Thing()
+    d[thing1] = 1
+    d[thing2] = 2
+    assert len(d) == 2
+    assert thing1 in d
+    assert set(d.keys()) == {thing1, thing2}
+    with ResumedTracing():
+        assert set(d.keys()) == set()
+        # You would expect the following assertions to work too
+        # However, they don't require getting the referred object, so they appear to still exist:
+        # assert thing1 not in d
+        # assert len(d) == 0
+
+
+def test_weakref_WeakValueDictionary(space):
+    d = WeakValueDictionary()
+    thing1 = Thing()
+    thing2 = Thing()
+    d[1] = thing1
+    d[2] = thing2
+    assert len(d) == 2
+    assert 1 in d
+    assert set(d.keys()) == {1, 2}
+    with ResumedTracing():
+        assert set(d.keys()) == set()
+        assert 1 not in d
+        # You would expect the length to update too.
+        # However, it doesn't require getting the referred object, so it appears to still exist:
+        # assert len(d) == 0
+
+
+@pytest.mark.xfail(reason="weakref.WeakSet is not yet supported")
+def test_weakref_WeakSet(space):
+    s = WeakSet()
+    thing1 = Thing()
+    s.add(thing1)
+    assert thing1 in s
+    with ResumedTracing():
+        assert thing1 not in s
+
+
+@pytest.mark.xfail(reason="weakref.proxy is not yet supported")
+def test_weakref_proxy(space):
+    thing1 = Thing()
+    thing1.x
+    p = proxy(thing1)
+    with pytest.raises(ReferenceError), ResumedTracing():
+        p.x

crosshair/libimpl/zliblib.py

@@ -0,0 +1,15 @@
+import zlib
+
+from crosshair.core import register_patch, with_realized_args
+
+
+def make_registrations():
+    for fn in (
+        zlib.adler32,
+        zlib.compress,
+        zlib.crc32,
+        zlib.decompress,
+        type(zlib.compressobj()).compress,
+        type(zlib.decompressobj()).decompress,
+    ):
+        register_patch(fn, with_realized_args(fn))

crosshair/libimpl/zliblib_test.py

@@ -0,0 +1,13 @@
+import zlib
+
+from crosshair.core import proxy_for_type, realize
+from crosshair.tracers import ResumedTracing
+
+
+def test_compress_on_symbolic(space):
+    buffer = proxy_for_type(bytes, "buffer")
+    with ResumedTracing():
+        space.add(len(buffer) == 1)
+        result = zlib.compress(buffer)
+    realized_buffer = realize(buffer)
+    assert zlib.decompress(result) == realized_buffer

crosshair/lsp_server.py

@@ -25,7 +25,11 @@ from lsprotocol.types import (
     Position,
     Range,
 )
-from pygls.server import LanguageServer
+
+try:
+    from pygls.lsp.server import LanguageServer  # (v2.x)
+except ImportError:
+    from pygls.server import LanguageServer  # (v1.x)
 
 from crosshair import __version__, env_info
 from crosshair.options import DEFAULT_OPTIONS, AnalysisOptionSet
@@ -42,6 +46,13 @@ class CrossHairLanguageServer(LanguageServer):
         self.options = options
         super().__init__("CrossHairServer", __version__)
 
+    def window_log_message(self, message: str):
+        # Just for version 1 & 2 compatibility
+        if hasattr(self, "show_message_log"):
+            self.show_message_log(message)
+        else:
+            super().window_log_message(message)
+
     CMD_REGISTER_COMPLETIONS = "registerCompletions"
     CMD_UNREGISTER_COMPLETIONS = "unregisterCompletions"
 
@@ -85,8 +96,8 @@ def publish_messages(
         for message in file_messages.values():
             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 ()))
+            # TODO: consider server.window_log_message()ing the long description
+            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:
@@ -116,7 +127,7 @@ class LocalState:
         max_watch_iterations: int = sys.maxsize,
     ) -> None:
         def log(*a):
-            pass  # self.server.show_message_log(*a)
+            pass  # self.server.window_log_message(*a)
 
         log("loop thread started")
         watcher = self.watcher
@@ -129,7 +140,7 @@ class LocalState:
                 return
             if restart:
                 numfiles = len(watcher._modtimes)
-                server.show_message_log(
+                server.window_log_message(
                     f"Scanning {numfiles} file(s) for properties to check."
                 )
                 max_uninteresting_iterations = (
@@ -163,7 +174,7 @@ class LocalState:
                 return
             if numpaths > 0:
                 status = f"Analyzed {numpaths} paths in {len(watcher._modtimes)} files."
-                server.show_message_log(status)
+                server.window_log_message(status)
             publish_messages(active_messages, server)
             if watcher._change_flag:
                 watcher._change_flag = False
@@ -177,7 +188,7 @@ _LS: Optional[LocalState] = None
 def getlocalstate(server: CrossHairLanguageServer) -> LocalState:
     global _LS
     if _LS is None:
-        server.show_message_log(env_info())
+        server.window_log_message(env_info())
         watcher = Watcher([], server.options)
         watcher.startpool()
         _LS = LocalState(watcher, server)
@@ -202,7 +213,7 @@ def update_paths(server: CrossHairLanguageServer):
             path = path.replace("/", "\\")
         paths.append(pathlib.Path(path))
     watcher = getlocalstate(server).watcher
-    server.show_message_log("New path set: " + repr(paths))
+    server.window_log_message("New path set: " + repr(paths))
     watcher.update_paths(paths)
 
 
@@ -214,14 +225,14 @@ def create_lsp_server(options: AnalysisOptionSet) -> CrossHairLanguageServer:
     def did_change(
         server: CrossHairLanguageServer, params: DidChangeTextDocumentParams
     ):
-        # server.show_message_log("did_change")
+        # server.window_log_message("did_change")
         uri = params.text_document.uri
         getlocalstate(server).active_messages[uri] = None
         server.publish_diagnostics(uri, [])
 
     @crosshair_lsp_server.feature(TEXT_DOCUMENT_DID_CLOSE)
     def did_close(server: CrossHairLanguageServer, params: DidCloseTextDocumentParams):
-        # server.show_message_log("did_close")
+        # server.window_log_message("did_close")
         uri = params.text_document.uri
         getlocalstate(server).active_messages[uri] = None
         server.publish_diagnostics(uri, [])