Check shared-strategy compatibility without reference to cache

Author: jobh

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

@@ -8,9 +8,12 @@
 # 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/.
 
+import warnings
 from collections.abc import Hashable
 from typing import Any, Optional
+from weakref import WeakKeyDictionary
 
+from hypothesis.errors import HypothesisWarning
 from hypothesis.internal.conjecture.data import ConjectureData
 from hypothesis.strategies._internal import SearchStrategy
 from hypothesis.strategies._internal.strategies import Ex
@@ -21,6 +24,9 @@ def __init__(self, base: SearchStrategy[Ex], key: Optional[Hashable] = None):
         super().__init__()
         self.key = key
         self.base = base
+        while isinstance(self.base, SharedStrategy):
+            # Unwrap nested shares
+            self.base = self.base.base
 
     def __repr__(self) -> str:
         if self.key is not None:
@@ -31,27 +37,30 @@ def __repr__(self) -> str:
     # Ideally would be -> Ex, but key collisions with different-typed values are
     # possible. See https://github.com/HypothesisWorks/hypothesis/issues/4301.
     def do_draw(self, data: ConjectureData) -> Any:
-        if self.key is None or getattr(self.base, "_is_singleton", False):
-            strat_label = id(self.base)
-        else:
-            # Assume that uncached strategies are distinguishable by their
-            # label. False negatives (even collisions w/id above) are ok as
-            # long as they are infrequent.
-            strat_label = self.base.label
         key = self.key or self
         if key not in data._shared_strategy_draws:
             drawn = data.draw(self.base)
-            data._shared_strategy_draws[key] = (strat_label, drawn)
+            data._shared_strategy_draws[key] = (drawn, self)
         else:
-            drawn_strat_label, drawn = data._shared_strategy_draws[key]
-            # Check disabled pending resolution of #4301
-            if drawn_strat_label != strat_label:  # pragma: no cover
-                pass
-                # warnings.warn(
-                #     f"Different strategies are shared under {key=}. This"
-                #     " risks drawing values that are not valid examples for the strategy,"
-                #     " or that have a narrower range than expected.",
-                #     HypothesisWarning,
-                #     stacklevel=1,
-                # )
+            drawn, other = data._shared_strategy_draws[key]
+
+            if other.base is not self.base:
+                # Check that the strategies shared under this key are equivalent,
+                # approximated as having equal `repr`s.
+                try:
+                    is_equivalent = self._equivalent_to[other]
+                except (AttributeError, KeyError) as e:
+                    if isinstance(e, AttributeError):
+                        self._equivalent_to = WeakKeyDictionary()
+                    is_equivalent = repr(self.base) == repr(other.base)
+                    self._equivalent_to[other] = is_equivalent
+                if not is_equivalent:
+                    warnings.warn(
+                        f"Different strategies are shared under {key=}. This"
+                        " risks drawing values that are not valid examples for the strategy,"
+                        " or that have a narrower range than expected."
+                        f" Conflicting strategies: ({self.base!r}, {other.base!r}).",
+                        HypothesisWarning,
+                        stacklevel=1,
+                    )
         return drawn

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

@@ -69,7 +69,6 @@ def cached_strategy(*args, **kwargs):
         else:
             result = fn(*args, **kwargs)
             if not isinstance(result, SearchStrategy) or result.is_cacheable:
-                result._is_singleton = True
                 _STRATEGY_CACHE[cache_key] = result
             return result
 

hypothesis-python/tests/cover/test_direct_strategies.py

@@ -586,7 +586,6 @@ def test_builds_error_messages(data):
     data.draw(st.sampled_from(AnEnum))
 
 
-@pytest.mark.skip("pending resolution of #4301")
 @pytest.mark.parametrize(
     "strat_a,strat_b",
     [
@@ -606,7 +605,6 @@ def test_builds_error_messages(data):
     ],
 )
 def test_incompatible_shared_strategies_warns(strat_a, strat_b):
-
     shared_a = st.shared(strat_a, key="share")
     shared_b = st.shared(strat_b, key="share")
 
@@ -629,16 +627,15 @@ def _composite2(draw):
     return draw(st.integers())
 
 
-@pytest.mark.skip("pending resolution of #4301")
 @pytest.mark.parametrize(
     "strat_a,strat_b",
     [
         (st.floats(allow_nan=False), st.floats(allow_nan=False)),
         (st.builds(float), st.builds(float)),
         (_composite1(), _composite1()),
         pytest.param(
-            st.floats(allow_nan=False),
-            st.floats(allow_nan=0),
+            st.floats(allow_nan=False, allow_infinity=False),
+            st.floats(allow_nan=False, allow_infinity=0),
             marks=pytest.mark.xfail(
                 raises=HypothesisWarning,
                 strict=True,
@@ -665,7 +662,7 @@ def _composite2(draw):
         ),
     ],
 )
-def test_compatible_shared_strategies_do_not_raise(strat_a, strat_b):
+def test_compatible_shared_strategies_do_not_warn(strat_a, strat_b):
     shared_a = st.shared(strat_a, key="share")
     shared_b = st.shared(strat_b, key="share")
 
@@ -677,3 +674,16 @@ def test_it(a, b):
     with warnings.catch_warnings():
         warnings.simplefilter("error", HypothesisWarning)
         test_it()
+
+
+def test_compatible_nested_shared_strategies_do_not_warn():
+    shared_a = st.shared(st.integers(), key="share")
+    shared_b = st.shared(st.integers(), key="share")
+    shared_c = st.shared(shared_a, key="share")
+
+    @given(shared_a, shared_b, shared_c)
+    @settings(max_examples=10, phases=[Phase.generate])
+    def test_it(a, b, c):
+        assert a == b == c
+
+    test_it()