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

crosshair/core_and_libs.py

@@ -11,6 +11,7 @@ from crosshair import opcode_intercept
 from crosshair.core import (
     AnalysisMessage,
     MessageType,
+    _reset_all_registrations,
     analyze_any,
     analyze_class,
     analyze_function,
@@ -23,23 +24,32 @@ from crosshair.core import (
 # Modules with registrations:
 from crosshair.libimpl import (
     arraylib,
+    binasciilib,
     builtinslib,
     codecslib,
     collectionslib,
     copylib,
     datetimelib,
+    decimallib,
+    fractionlib,
     functoolslib,
+    hashliblib,
     heapqlib,
     importliblib,
     iolib,
+    ipaddresslib,
     itertoolslib,
     jsonlib,
     mathlib,
+    oslib,
     randomlib,
     relib,
     timelib,
+    typeslib,
     unicodedatalib,
     urlliblib,
+    weakreflib,
+    zliblib,
 )
 from crosshair.options import AnalysisKind, AnalysisOptions
 from crosshair.tracers import NoTracing, ResumedTracing
@@ -71,25 +81,35 @@ __all__ = [
 
 
 def _make_registrations():
+    _reset_all_registrations()
     arraylib.make_registrations()
+    binasciilib.make_registrations()
     builtinslib.make_registrations()
     codecslib.make_registrations()
     collectionslib.make_registrations()
     copylib.make_registrations()
     datetimelib.make_registrations()
+    decimallib.make_registrations()
     functoolslib.make_registrations()
+    fractionlib.make_registrations()
+    hashliblib.make_registrations()
     heapqlib.make_registrations()
     jsonlib.make_registrations()
     importliblib.make_registrations()
     iolib.make_registrations()
+    ipaddresslib.make_registrations()
     itertoolslib.make_registrations()
     mathlib.make_registrations()
+    oslib.make_registrations()
     randomlib.make_registrations()
     relib.make_registrations()
     timelib.make_registrations()
+    typeslib.make_registrations()
     unicodedatalib.make_registrations()
     urlliblib.make_registrations()
     opcode_intercept.make_registrations()
+    weakreflib.make_registrations()
+    zliblib.make_registrations()
 
     plugin_entries = entry_points(group="crosshair.plugin")
     for plugin_entry in plugin_entries:

crosshair/core_regestered_types_test.py

@@ -0,0 +1,82 @@
+import collections
+import re
+from dataclasses import dataclass
+from typing import (
+    Any,
+    BinaryIO,
+    Callable,
+    Final,
+    List,
+    NamedTuple,
+    NoReturn,
+    SupportsBytes,
+    SupportsComplex,
+    Union,
+)
+
+import pytest  # type: ignore
+import typing_inspect  # type: ignore
+
+from crosshair.core import _SIMPLE_PROXIES, proxy_for_type
+from crosshair.dynamic_typing import origin_of
+from crosshair.tracers import ResumedTracing
+from crosshair.util import CrosshairUnsupported, debug, name_of_type
+
+"""
+Tests that the builtin and standard library types behave like their
+counterparts.
+"""
+
+
+possible_args = [
+    (),
+    (Any,),
+    (Any, Any),
+    (Any, Any, Any),
+]
+
+untested_types = {
+    # These types won't check at runtime:
+    Union,
+    NoReturn,
+    Final,
+    BinaryIO,
+    SupportsBytes,
+    SupportsComplex,
+    # Callable actually works ok but can throw IgnoreAttempt
+    collections.abc.Callable,
+    # TODO: make a symbolic NamedTuple that intercepts attribute access:
+    NamedTuple,
+}
+
+
+comparisons: List = []
+for typ, creator in _SIMPLE_PROXIES.items():
+    if typ in untested_types:
+        continue
+    name = name_of_type(typ)
+    comparisons.append(pytest.param(typ, creator, id=name))
+    if typing_inspect.is_generic_type(typ) and hasattr(typ, "__getitem__"):
+        for nargs in range(1, 3):
+            type_args = tuple([Any for _ in range(nargs)])
+            try:
+                typ_paramed = typ.__getitem__(type_args)
+            except TypeError:
+                pass
+            else:
+                comparisons.append(
+                    pytest.param(typ_paramed, creator, id=name + "_with_{nargs}_args")
+                )
+
+
+@pytest.mark.parametrize("typ,creator", comparisons)
+def test_patch(typ: type, creator: Callable, space):
+    debug("Patch test:", typ, creator)
+    try:
+        proxy = proxy_for_type(typ, "x")
+    except CrosshairUnsupported:
+        debug("Ignored pass - CrossHair explicitly does not support this type")
+        return
+    origin = origin_of(typ)
+    with ResumedTracing():
+        assert isinstance(proxy, origin)