crosshair-tool 0.0.83__cp39-cp39-macosx_10_9_universal2.whl → 0.0.84__cp39-cp39-macosx_10_9_universal2.whl

crosshair/diff_behavior_test.py

@@ -81,7 +81,7 @@ def _sum_list_rewrite_2(int_list):
     return count
 
 
-class BehaviorDiffTest(unittest.TestCase):
+class TestBehaviorDiff:
     def test_diff_method(self):
         diffs = diff_behavior(
             walk_qualname(Base, "foo"),
@@ -89,10 +89,9 @@ class BehaviorDiffTest(unittest.TestCase):
             DEFAULT_OPTIONS.overlay(max_iterations=10),
         )
         assert isinstance(diffs, list)
-        self.assertEqual(
-            [(d.result1.return_repr, d.result2.return_repr) for d in diffs],
-            [("10", "11")],
-        )
+        assert [(d.result1.return_repr, d.result2.return_repr) for d in diffs] == [
+            ("10", "11")
+        ]
 
     def test_diff_staticmethod(self):
         diffs = diff_behavior(
@@ -100,20 +99,20 @@ class BehaviorDiffTest(unittest.TestCase):
             foo2,
             DEFAULT_OPTIONS.overlay(max_iterations=10),
         )
-        self.assertEqual(diffs, [])
+        assert diffs == []
 
     def test_diff_behavior_same(self) -> None:
         diffs = diff_behavior(foo1, foo2, DEFAULT_OPTIONS.overlay(max_iterations=10))
-        self.assertEqual(diffs, [])
+        assert diffs == []
 
     def test_diff_behavior_different(self) -> None:
         diffs = diff_behavior(foo1, foo3, DEFAULT_OPTIONS.overlay(max_iterations=10))
-        self.assertEqual(len(diffs), 1)
+        assert len(diffs) == 1
         diff = diffs[0]
         assert isinstance(diff, BehaviorDiff)
-        self.assertGreater(int(diff.args["x"]), 1000)
-        self.assertEqual(diff.result1.return_repr, "100")
-        self.assertEqual(diff.result2.return_repr, "1000")
+        assert int(diff.args["x"]) > 1000
+        assert diff.result1.return_repr == "100"
+        assert diff.result2.return_repr == "1000"
 
     def test_diff_behavior_mutation(self) -> None:
         def cut_out_item1(a: List[int], i: int):
@@ -130,10 +129,10 @@ class BehaviorDiffTest(unittest.TestCase):
             opts,
         )
         assert not isinstance(diffs, str)
-        self.assertEqual(len(diffs), 1)
+        assert len(diffs) == 1
         diff = diffs[0]
-        self.assertGreater(len(diff.args["a"]), 1)
-        self.assertEqual(diff.args["i"], "-1")
+        assert len(diff.args["a"]) > 1
+        assert diff.args["i"] == "-1"
 
     def test_example_coverage(self) -> None:
         # Try to get examples that highlist the differences in the code.
@@ -159,7 +158,7 @@ class BehaviorDiffTest(unittest.TestCase):
         debug("diffs=", diffs)
         assert not isinstance(diffs, str)
         return_vals = set((d.result1.return_repr, d.result2.return_repr) for d in diffs)
-        self.assertEqual(return_vals, {("False", "None"), ("False", "True")})
+        assert return_vals == {("False", "None"), ("False", "True")}
 
 
 def test_diff_behavior_lambda() -> None:
@@ -262,9 +261,3 @@ def test_diff_behavior_nan() -> None:
         DEFAULT_OPTIONS,
     )
     assert diffs == []
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/dynamic_typing.py

@@ -1,8 +1,12 @@
 import collections.abc
 import typing
-from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Type
+from inspect import Parameter, Signature
+from itertools import zip_longest
+from typing import Any, Callable, Dict, List, Mapping, Optional, Sequence, Tuple, Type
 
-import typing_inspect  # type: ignore
+import typing_inspect
+
+from crosshair.util import debug  # type: ignore
 
 _EMPTYSET: frozenset = frozenset()
 
@@ -234,3 +238,88 @@ def realize(pytype: Type, bindings: Mapping[object, type]) -> object:
     if pytype_origin is Callable:  # Callable args get flattened
         newargs = [newargs[:-1], newargs[-1]]
     return pytype_origin.__getitem__(tuple(newargs))
+
+
+def isolate_var_params(
+    sig: Signature,
+) -> Tuple[
+    List[Parameter], Dict[str, Parameter], Optional[Parameter], Optional[Parameter]
+]:
+    pos_only_params: List[Parameter] = []
+    keyword_params: Dict[str, Parameter] = {}
+    var_positional: Optional[Parameter] = None
+    var_keyword: Optional[Parameter] = None
+    for name, param in sig.parameters.items():
+        if param.kind == Parameter.VAR_POSITIONAL:
+            var_positional = param
+        elif param.kind == Parameter.VAR_KEYWORD:
+            var_keyword = param
+        elif param.kind == Parameter.POSITIONAL_ONLY:
+            pos_only_params.append(param)
+        else:
+            keyword_params[name] = param
+    return pos_only_params, keyword_params, var_positional, var_keyword
+
+
+def intersect_signatures(
+    sig1: Signature,
+    sig2: Signature,
+) -> Signature:
+    """
+    Approximate the intersection of two signatures.
+    The resulting signature may be overly loose
+    (matching some inputs that neither of the original signatures would match),
+    but it should cover all the inputs for each original signature.
+
+    One minor exception: All arguments that are allowed to be called as
+    keyword arguments will be converted to keyword-only arguments.
+    We do this to resolve the abiguity when position-or-keyword arguments
+    appear in the same position but with different names.
+    """
+    pos1, key1, var_pos1, var_key1 = isolate_var_params(sig1)
+    pos2, key2, var_pos2, var_key2 = isolate_var_params(sig2)
+    is_squishy1 = var_pos1 is not None or var_key1 is not None
+    is_squishy2 = var_pos2 is not None or var_key2 is not None
+    out_params: Dict[str, Parameter] = {}
+    for (p1, p2) in zip_longest(pos1, pos2):
+        if p1 is None:
+            if is_squishy1:
+                out_params[p2.name] = p2
+        elif p2 is None:
+            if is_squishy2:
+                out_params[p1.name] = p1
+        elif unify(p1.annotation, p2.annotation):
+            out_params[p1.name] = p1
+        else:
+            out_params[p2.name] = p2
+    for key in [
+        k
+        for pair in zip_longest(key1.keys(), key2.keys())
+        for k in pair
+        if k is not None
+    ]:
+        if key not in key2:
+            if is_squishy2:
+                out_params[key] = key1[key].replace(kind=Parameter.KEYWORD_ONLY)
+            continue
+        if key not in key1:
+            if is_squishy1:
+                out_params[key] = key2[key].replace(kind=Parameter.KEYWORD_ONLY)
+            continue
+        if unify(key1[key].annotation, key2[key].annotation):
+            out_params[key] = key1[key].replace(kind=Parameter.KEYWORD_ONLY)
+        else:
+            out_params[key] = key2[key].replace(kind=Parameter.KEYWORD_ONLY)
+    if var_pos1 and var_pos2:
+        out_params[var_pos1.name] = var_pos1
+    if var_key1 and var_key2:
+        out_params[var_key1.name] = var_key1
+    if unify(sig1.return_annotation, sig2.return_annotation):
+        out_return_annotation = sig1.return_annotation
+    else:
+        out_return_annotation = sig2.return_annotation
+    result = Signature(
+        parameters=list(out_params.values()), return_annotation=out_return_annotation
+    )
+    debug("Combined __init__ and __new__ signatures", sig1, "and", sig2, "into", result)
+    return result

crosshair/dynamic_typing_test.py

@@ -1,4 +1,5 @@
 import collections
+from inspect import Parameter, Signature, signature
 from typing import (
     Callable,
     Dict,
@@ -6,15 +7,25 @@ from typing import (
     Iterable,
     List,
     Mapping,
+    Optional,
     Sequence,
     Tuple,
     TypeVar,
     Union,
 )
 
+import pytest
 from typing_extensions import TypedDict
 
-from crosshair.dynamic_typing import get_bindings_from_type_arguments, realize, unify
+from crosshair.dynamic_typing import (
+    get_bindings_from_type_arguments,
+    intersect_signatures,
+    realize,
+    unify,
+)
+from crosshair.options import AnalysisOptionSet
+from crosshair.statespace import CANNOT_CONFIRM
+from crosshair.test_util import check_states
 
 _T = TypeVar("_T")
 _U = TypeVar("_U")
@@ -121,3 +132,64 @@ def test_bindings_from_type_arguments():
     var_mapping = get_bindings_from_type_arguments(Pair[int, str])
     assert var_mapping == {_U: int, _T: str}
     assert realize(List[_U], var_mapping) == List[int]
+
+
+def test_intersect_signatures_basic():
+    def f1(x: int, y: str, **kw) -> List[bool]:
+        return []
+
+    def f2(x: bool, *extra: str, **kw) -> List[int]:
+        return []
+
+    intersection = intersect_signatures(signature(f1), signature(f2))
+    assert intersection is not None
+    assert intersection.parameters == {
+        "x": Parameter("x", kind=Parameter.KEYWORD_ONLY, annotation=bool),
+        "y": Parameter("y", kind=Parameter.KEYWORD_ONLY, annotation=str),
+        "kw": Parameter("kw", kind=Parameter.VAR_KEYWORD),
+    }
+    assert intersection.return_annotation == List[bool]
+
+
+def test_intersect_signatures_typevars():
+    _T = TypeVar("_T")
+
+    def f1(cc, *args, **kwds):
+        pass
+
+    def f2(dd, left: Optional[_T], right: Optional[_T]):
+        pass
+
+    intersection = intersect_signatures(signature(f1), signature(f2))
+    assert intersection is not None
+    expected = {
+        "dd": Parameter("dd", kind=Parameter.KEYWORD_ONLY),
+        "left": Parameter("left", kind=Parameter.KEYWORD_ONLY, annotation=Optional[_T]),
+        "right": Parameter(
+            "right", kind=Parameter.KEYWORD_ONLY, annotation=Optional[_T]
+        ),
+    }
+    assert intersection.parameters == expected
+
+
+@pytest.mark.skip(
+    reason="The inspect module doesn't expose runtime type information yet"
+)
+def test_intersect_signature_with_crosshair():
+    def check_intersect_signatures(
+        sig1: Signature, sig2: Signature, pos_args: List, kw_args: Mapping[str, object]
+    ) -> None:
+        """post: True"""
+
+        def _sig_bindable(sig: Signature) -> bool:
+            try:
+                sig.bind(*pos_args, **kw_args)
+                return True
+            except TypeError:
+                return False
+
+        if _sig_bindable(sig1) or _sig_bindable(sig2):
+            intersection = intersect_signatures(sig1, sig2)
+            assert _sig_bindable(intersection)
+
+    check_states(check_intersect_signatures, CANNOT_CONFIRM)

crosshair/enforce_test.py

@@ -1,6 +1,5 @@
 import abc
 import sys
-import unittest
 from contextlib import ExitStack
 
 import pytest
@@ -57,21 +56,21 @@ class Enforcement(ExitStack):
         COMPOSITE_TRACER.trace_caller()
 
 
-class CoreTest(unittest.TestCase):
+class TestCore:
     def test_enforce_conditions(self) -> None:
-        self.assertEqual(foo(-1), -2)  # unchecked
+        assert foo(-1) == -2  # unchecked
         with Enforcement():
-            self.assertEqual(foo(50), 100)
-            with self.assertRaises(PreconditionFailed):
+            assert foo(50) == 100
+            with pytest.raises(PreconditionFailed):
                 foo(-1)
-            with self.assertRaises(PostconditionFailed):
+            with pytest.raises(PostconditionFailed):
                 foo(0)
 
     def test_class_enforce(self) -> None:
         Pokeable().pokeby(-1)  # no exception (yet!)
         with Enforcement():
             Pokeable().poke()
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 Pokeable().pokeby(-1)
 
     def test_enforce_on_uncopyable_value(self) -> None:
@@ -81,7 +80,7 @@ class CoreTest(unittest.TestCase):
 
         not_copyable = NotCopyable()
         with Enforcement():
-            with self.assertRaises(AttributeError):
+            with pytest.raises(AttributeError):
                 same_thing(not_copyable)
 
 
@@ -114,19 +113,19 @@ class DerivedFooable(BaseFooable):
         """pre: x > 0"""
 
 
-class TrickyCasesTest(unittest.TestCase):
+class TestTrickyCases:
     def test_attrs_restored_properly(self) -> None:
         orig_class_dict = DerivedFooable.__dict__.copy()
         with Enforcement():
             pass
         for k, v in orig_class_dict.items():
-            self.assertIs(
-                DerivedFooable.__dict__[k], v, f'member "{k}" changed afer encforcement'
-            )
+            assert (
+                DerivedFooable.__dict__[k] is v
+            ), f'member "{k}" changed afer encforcement'
 
     def test_enforcement_of_class_methods(self) -> None:
         with Enforcement():
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 BaseFooable.class_foo(50)
         with Enforcement():
             DerivedFooable.class_foo(50)
@@ -134,14 +133,14 @@ class TrickyCasesTest(unittest.TestCase):
     def test_enforcement_of_static_methods(self) -> None:
         with Enforcement():
             DerivedFooable.static_foo(50)
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 BaseFooable.static_foo(50)
 
     def test_super_method_enforced(self) -> None:
         with Enforcement():
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 DerivedFooable().foo_only_in_super(50)
-            with self.assertRaises(PreconditionFailed):
+            with pytest.raises(PreconditionFailed):
                 DerivedFooable().foo(-1)
             # Derived class has a weaker precondition, so this is OK:
             DerivedFooable().foo(50)
@@ -181,9 +180,3 @@ def test_enforcement_init_on_abcmeta() -> None:
         with pytest.raises(PostconditionFailed):
             WithMetaclass(55)
         WithMetaclass(99)
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/fnutil_test.py

@@ -1,7 +1,6 @@
 import builtins
 import inspect
 import sys
-import unittest
 from dataclasses import dataclass
 from typing import Generic
 
@@ -74,9 +73,3 @@ def test_load_function_at_line():
 
 def test_FunctionInfo_get_callable_on_generic():
     assert FunctionInfo.from_class(Generic, "__class_getitem__").get_callable() is None
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/libimpl/arraylib.py

@@ -1,5 +1,6 @@
+import sys
 from array import array
-from typing import BinaryIO, ByteString, Dict, Iterable, List, Sequence, Tuple
+from typing import BinaryIO, Dict, Iterable, List, Sequence, Tuple
 
 import z3  # type: ignore
 
@@ -29,8 +30,17 @@ INT_TYPE_BOUNDS: Dict[str, Tuple[int, int]] = {
 INT_TYPE_SIZE = {c: array(c).itemsize for c in INT_TYPE_BOUNDS.keys()}
 
 
-def is_bytes_like(obj: object) -> bool:
-    return isinstance(obj, (ByteString, array))
+if sys.version_info >= (3, 12):
+    from collections.abc import Buffer
+
+    def is_bytes_like(obj: object) -> bool:
+        return isinstance(obj, Buffer)
+
+else:
+    from collections.abc import ByteString
+
+    def is_bytes_like(obj: object) -> bool:
+        return isinstance(obj, (ByteString, array))
 
 
 def pick_code(space: StateSpace) -> Tuple[str, int, int]:

crosshair/libimpl/binasciilib.py

@@ -1,7 +1,6 @@
 import binascii
-from collections.abc import ByteString
 from functools import partial
-from typing import Dict, Iterable, Tuple
+from typing import Dict, Iterable, Tuple, Union
 
 from crosshair.core import register_patch
 from crosshair.libimpl.builtinslib import _ALL_BYTES_TYPES, SymbolicBytes
@@ -89,7 +88,7 @@ _DECODE_MAPPER_BASE64_STRICT = partial(
 _ENCODE_MAPPER_BASE64 = partial(_remap, _ENCODE_BASE64_MAP)
 
 
-def make_bytes(arg: object) -> ByteString:
+def make_bytes(arg: object) -> Union[bytes, bytearray, memoryview]:
     if isinstance(arg, (bytes, bytearray, memoryview)):
         return arg
     if isinstance(arg, str):

crosshair/libimpl/builtinslib.py

@@ -21,7 +21,6 @@ from sys import maxunicode
 from typing import (
     Any,
     BinaryIO,
-    ByteString,
     Callable,
     Dict,
     FrozenSet,
@@ -127,9 +126,9 @@ from crosshair.util import (
 from crosshair.z3util import z3And, z3Eq, z3Ge, z3Gt, z3IntVal, z3Not, z3Or
 
 if sys.version_info >= (3, 12):
-    from collections.abc import Buffer as BufferAbc
+    from collections.abc import Buffer
 else:
-    from collections.abc import ByteString as BufferAbc
+    from collections.abc import ByteString as Buffer
 
 
 _T = TypeVar("_T")
@@ -3968,7 +3967,7 @@ def is_ascii_space_ord(char_ord: int):
     )
 
 
-class BytesLike(BufferAbc, AbcString, CrossHairValue):
+class BytesLike(Buffer, AbcString, CrossHairValue):
     def __eq__(self, other) -> bool:
         if not isinstance(other, _ALL_BYTES_TYPES):
             return False
@@ -5038,11 +5037,11 @@ def _str_percent_format(self, other):
 
 
 def _bytes_join(self, itr) -> str:
-    return _join(self, itr, self_type=bytes, item_type=BufferAbc)
+    return _join(self, itr, self_type=bytes, item_type=Buffer)
 
 
 def _bytearray_join(self, itr) -> str:
-    return _join(self, itr, self_type=bytearray, item_type=BufferAbc)
+    return _join(self, itr, self_type=bytearray, item_type=Buffer)
 
 
 def _str_format(self, *a, **kw) -> Union[AnySymbolicStr, str]:
@@ -5178,7 +5177,7 @@ def make_registrations():
     register_type(SupportsFloat, lambda p: p(float))
     register_type(SupportsInt, lambda p: p(int))
     register_type(SupportsRound, lambda p: p(float))
-    register_type(SupportsBytes, lambda p: p(ByteString))
+    register_type(SupportsBytes, lambda p: p(Buffer))
     register_type(SupportsComplex, lambda p: p(complex))
 
     # Patches

crosshair/libimpl/builtinslib_test.py

@@ -8,7 +8,6 @@ import math
 import operator
 import re
 import sys
-import unittest
 from abc import ABC, abstractmethod
 from array import array
 from numbers import Integral
@@ -2882,7 +2881,7 @@ def test_frozenset___or__(space):
         assert len(s1 | s2) == 2
 
 
-class ProtocolsTest(unittest.TestCase):
+class TestProtocols:
     # TODO: move most of this into a collectionslib_test.py file
     def test_hashable_values_fail(self) -> None:
         def f(b: bool, i: int, t: Tuple[str, ...]) -> int:
@@ -3657,9 +3656,3 @@ def TODO_test_deepcopy_independence():
         with NoTracing():
             assert ls[0] is not lscopy[0]
         # Next try mutation on one and test the other...
-
-
-if __name__ == "__main__":
-    if ("-v" in sys.argv) or ("--verbose" in sys.argv):
-        set_debug(True)
-    unittest.main()

crosshair/libimpl/collectionslib.py

@@ -1,4 +1,5 @@
 import collections
+import sys
 from typing import (
     Any,
     Callable,
@@ -245,5 +246,8 @@ def make_registrations():
 
     register_type(collections.abc.MutableSet, lambda p, t=Any: p(Set[t]))  # type: ignore
 
-    register_type(collections.abc.ByteString, lambda p: p(bytes))
+    if sys.version_info < (3, 14):
+        register_type(collections.abc.ByteString, lambda p: p(bytes))
+    if sys.version_info >= (3, 12):
+        register_type(collections.abc.Buffer, lambda p: p(bytes))
     register_type(collections.abc.Hashable, lambda p: p(int))

crosshair/libimpl/collectionslib_test.py

@@ -1,14 +1,23 @@
-import collections
+import sys
+from collections import Counter, defaultdict, deque, namedtuple
 from copy import deepcopy
-from typing import Counter, DefaultDict, Deque, Tuple
+from inspect import Parameter, Signature
+from typing import Counter, DefaultDict, Deque, NamedTuple, Tuple
 
 import pytest
 
-from crosshair.core import deep_realize, proxy_for_type, realize, standalone_statespace
+from crosshair.core import (
+    deep_realize,
+    get_constructor_signature,
+    proxy_for_type,
+    realize,
+    standalone_statespace,
+)
 from crosshair.libimpl.collectionslib import ListBasedDeque
 from crosshair.statespace import CANNOT_CONFIRM, CONFIRMED, POST_FAIL, MessageType
 from crosshair.test_util import check_states
 from crosshair.tracers import NoTracing, ResumedTracing
+from crosshair.util import CrossHairValue
 
 
 @pytest.fixture
@@ -24,7 +33,7 @@ def test_counter_symbolic_deep(space):
 
 
 def test_counter_deep(space):
-    d = collections.Counter()
+    d = Counter()
     with ResumedTracing():
         deep_realize(d)
         deepcopy(d)
@@ -176,7 +185,7 @@ def test_deque_extendleft_method() -> None:
         """
         Can any deque be extended by itself and form this palindrome?
 
-        post[ls]: ls != collections.deque([1, 2, 3, 3, 2, 1])
+        post[ls]: ls != deque([1, 2, 3, 3, 2, 1])
         """
         ls.extendleft(ls)
 
@@ -185,22 +194,22 @@ def test_deque_extendleft_method() -> None:
 
 def test_deque_add_symbolic_to_concrete():
     with standalone_statespace as space:
-        d = ListBasedDeque([1, 2]) + collections.deque([3, 4])
+        d = ListBasedDeque([1, 2]) + deque([3, 4])
         assert list(d) == [1, 2, 3, 4]
 
 
 def test_deque_eq():
     with standalone_statespace as space:
         assert ListBasedDeque([1, 2]) == ListBasedDeque([1, 2])
-        assert collections.deque([1, 2]) == ListBasedDeque([1, 2])
+        assert deque([1, 2]) == ListBasedDeque([1, 2])
         assert ListBasedDeque([1, 2]) != ListBasedDeque([1, 55])
-        assert collections.deque([1, 2]) != ListBasedDeque([1, 55])
+        assert deque([1, 2]) != ListBasedDeque([1, 55])
 
 
 def test_defaultdict_repr_equiv(test_list) -> None:
     def f(symbolic: DefaultDict[int, int]) -> Tuple[dict, dict]:
         """post: _[0] == _[1]"""
-        concrete = collections.defaultdict(symbolic.default_factory, symbolic.items())
+        concrete = defaultdict(symbolic.default_factory, symbolic.items())
         return (symbolic, concrete)
 
     check_states(f, CANNOT_CONFIRM)
@@ -243,16 +252,73 @@ def test_defaultdict_realize():
     with standalone_statespace:
         with NoTracing():
             d = proxy_for_type(DefaultDict[int, int], "d")
-            assert type(realize(d)) is collections.defaultdict
+            assert type(realize(d)) is defaultdict
 
 
 #
-# We don't patch namedtuple, but namedtuple performs magic like dynamic type
+# We don't patch namedtuple, but namedtuple performs magic dynamic type
 # generation, which can interfere with CrossHair.
 #
 
 
 def test_namedtuple_creation():
     with standalone_statespace:
-        # Ensure type creation doesn't raise exception:
-        Color = collections.namedtuple("Color", ("name", "hex"))
+        # Ensure type creation under trace doesn't raise exception:
+        Color = namedtuple("Color", ("name", "hex"))
+
+
+def test_namedtuple_argument_detection_untyped():
+    UntypedColor = namedtuple("UntypedColor", ("name", "hex"))
+    expected_signature = Signature(
+        parameters=[
+            Parameter("name", Parameter.POSITIONAL_OR_KEYWORD),
+            Parameter("hex", Parameter.POSITIONAL_OR_KEYWORD),
+        ],
+        return_annotation=Signature.empty,
+    )
+    assert get_constructor_signature(UntypedColor) == expected_signature
+
+
+def test_namedtuple_argument_detection_typed_with_subclass():
+    class ClassTypedColor(NamedTuple):
+        name: str
+        hex: int
+
+    expected_parameters = {
+        "name": Parameter("name", Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+        "hex": Parameter("hex", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+    }
+    assert get_constructor_signature(ClassTypedColor).parameters == expected_parameters
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9),
+    reason="Functional namedtuple field types supported on Python >= 3.9",
+)
+def test_namedtuple_argument_detection_typed_functionally():
+    FunctionallyTypedColor = NamedTuple(
+        "FunctionallyTypedColor", [("name", str), ("hex", int)]
+    )
+    expected_parameters = {
+        "name": Parameter("name", Parameter.POSITIONAL_OR_KEYWORD, annotation=str),
+        "hex": Parameter("hex", Parameter.POSITIONAL_OR_KEYWORD, annotation=int),
+    }
+    assert (
+        get_constructor_signature(FunctionallyTypedColor).parameters
+        == expected_parameters
+    )
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9),
+    reason="Functional namedtuple field types supported on Python >= 3.9",
+)
+def test_namedtuple_symbolic_creation(space):
+    UntypedColor = namedtuple("Color", "name hex")
+    Color = NamedTuple("Color", [("name", str), ("hex", int)])
+    untyped_color = proxy_for_type(UntypedColor, "color")
+    assert isinstance(untyped_color.hex, CrossHairValue)
+    color = proxy_for_type(Color, "color")
+    with ResumedTracing():
+        assert space.is_possible(color.hex == 5)
+        assert space.is_possible(color.hex == 10)