Support recursive forward references in from_type

Add support for self-referential type aliases like `A = list[Union["A", str]]`
in from_type(). Previously such recursive types would raise ResolutionFailed,
but now Hypothesis can resolve them by looking up forward references in the
caller's namespace.

Fixes #4542

Author: claude

hypothesis-python/RELEASE.rst

@@ -0,0 +1,8 @@
+RELEASE_TYPE: patch
+
+This patch adds support for recursive forward references in
+:func:`~hypothesis.strategies.from_type`, such as
+``A = list[Union["A", str]]`` (:issue:`4542`).
+Previously, such recursive type aliases would raise a ``ResolutionFailed``
+error. Now, Hypothesis can automatically resolve the forward reference
+by looking it up in the caller's namespace.

hypothesis-python/src/hypothesis/strategies/_internal/core.py

@@ -1369,6 +1369,11 @@ def from_type_guarded(thing):
     if not types.is_a_type(thing):
         if isinstance(thing, str):
             # See https://github.com/HypothesisWorks/hypothesis/issues/3016
+            # String forward references like "LinkedList" can be converted to
+            # ForwardRef objects if they are valid Python identifiers.
+            # See https://github.com/HypothesisWorks/hypothesis/issues/4542
+            if thing.isidentifier():
+                return deferred(lambda thing=thing: from_type(typing.ForwardRef(thing)))
             raise InvalidArgument(
                 f"Got {thing!r} as a type annotation, but the forward-reference "
                 "could not be resolved from a string to a type.  Consider using "

hypothesis-python/src/hypothesis/strategies/_internal/types.py

@@ -214,6 +214,25 @@ def type_sorting_key(t):
     return (is_container, repr(t))
 
 
+def _resolve_forward_ref_in_caller(forward_arg: str):
+    """Try to resolve a forward reference name by walking up the call stack.
+
+    This allows us to resolve recursive forward references like:
+        A = list[Union["A", str]]
+
+    where "A" refers to the type alias being defined.
+    """
+    frame = sys._getframe()
+    while frame is not None:
+        # Check locals first, then globals
+        if forward_arg in frame.f_locals:
+            return frame.f_locals[forward_arg]
+        if forward_arg in frame.f_globals:
+            return frame.f_globals[forward_arg]
+        frame = frame.f_back
+    return None
+
+
 def _compatible_args(args, superclass_args):
     """Check that the args of two generic types are compatible for try_issubclass."""
     assert superclass_args is not None
@@ -562,6 +581,12 @@ def from_typing_type(thing):
         and thing.__forward_arg__ in vars(builtins)
     ):
         return st.from_type(getattr(builtins, thing.__forward_arg__))
+    elif (not mapping) and isinstance(thing, typing.ForwardRef):
+        # Try to resolve non-builtin forward references by walking up the call stack.
+        # This handles recursive forward references like A = list[Union["A", str]].
+        resolved = _resolve_forward_ref_in_caller(thing.__forward_arg__)
+        if resolved is not None and is_a_type(resolved):
+            return st.from_type(resolved)
 
     def is_maximal(t):
         # For each k in the mapping, we use it if it's the most general type
@@ -1140,8 +1165,7 @@ def resolve_strategies(typ):
     return st.shared(
         st.sampled_from(
             # Constraints may be None or () on various Python versions.
-            getattr(thing, "__constraints__", None)
-            or builtin_scalar_types,
+            getattr(thing, "__constraints__", None) or builtin_scalar_types,
         ),
         key=type_var_key,
     ).flatmap(st.from_type)

hypothesis-python/tests/nocover/test_type_lookup_forward_ref.py

@@ -8,14 +8,14 @@
 # v. 2.0. If a copy of the MPL was not distributed with this file, You can
 # obtain one at https://mozilla.org/MPL/2.0/.
 
-from typing import Dict as _Dict, ForwardRef, Union
+from typing import Dict as _Dict, Union
 
 import pytest
 
 from hypothesis import given, settings, strategies as st
 from hypothesis.errors import ResolutionFailed
 
-from tests.common import utils
+from tests.common.debug import find_any
 from tests.common.utils import skipif_threading
 
 # error only occurs with typing variants
@@ -30,24 +30,36 @@
 )
 
 
+# Self-referential recursive forward references
+# See https://github.com/HypothesisWorks/hypothesis/issues/4542
+
+
+def test_self_referential_forward_ref():
+    # The example from issue #4542 - a type alias that references itself
+    A = list[Union["A", str]]
+    # This should work without needing manual registration
+    result = find_any(st.from_type(A))
+    assert isinstance(result, list)
+
+
+def test_self_referential_forward_ref_nested():
+    # Test with nested self-reference
+    Tree = dict[str, Union["Tree", int]]
+    result = find_any(st.from_type(Tree))
+    assert isinstance(result, dict)
+
+
 @skipif_threading  # weird errors around b_strategy scope?
 @given(st.data())
 def test_mutually_recursive_types_with_typevar(data):
-    # The previously-failing example from the issue
+    # The previously-failing example from issue #2722
+    # Now works because forward refs are resolved via caller namespace lookup
     A = _Dict[bool, "B"]
     B = Union[list[bool], A]
 
-    with pytest.raises(ResolutionFailed, match=r"Could not resolve ForwardRef\('B'\)"):
-        data.draw(st.from_type(A))
-
-    with utils.temp_registered(
-        ForwardRef("B"),
-        lambda _: st.deferred(lambda: b_strategy),
-    ):
-        b_strategy = st.from_type(B)
-        data.draw(b_strategy)
-        data.draw(st.from_type(A))
-        data.draw(st.from_type(B))
+    # Both A and B are in scope, so forward refs should resolve
+    data.draw(st.from_type(A))
+    data.draw(st.from_type(B))
 
 
 @skipif_threading  # weird errors around d_strategy scope?
@@ -58,14 +70,14 @@ def test_mutually_recursive_types_with_typevar_alternate(data):
     C = Union[list[bool], "D"]
     D = dict[bool, C]
 
-    with pytest.raises(ResolutionFailed, match=r"Could not resolve ForwardRef\('D'\)"):
-        data.draw(st.from_type(C))
-
-    with utils.temp_registered(
-        ForwardRef("D"),
-        lambda _: st.deferred(lambda: d_strategy),
-    ):
-        d_strategy = st.from_type(D)
-        data.draw(d_strategy)
-        data.draw(st.from_type(C))
-        data.draw(st.from_type(D))
+    # Both C and D are in scope, so forward refs should resolve
+    data.draw(st.from_type(C))
+    data.draw(st.from_type(D))
+
+
+def test_forward_ref_to_undefined_still_fails():
+    # Forward references to undefined names should still fail
+    A = _Dict[bool, "UndefinedType"]  # noqa: F821
+
+    with pytest.raises(ResolutionFailed, match=r"Could not resolve"):
+        find_any(st.from_type(A))