Migrate most shrinker functions to the ir

hypothesis-python/src/hypothesis/internal/conjecture/data.py

@@ -777,10 +777,6 @@ def end(self, i: int) -> int:
  """Equivalent to self[i].end."""
  return self.endpoints[i]
 
- def bounds(self, i: int) -> Tuple[int, int]:
- """Equivalent to self[i].bounds."""
- return (self.start(i), self.end(i))
-
  def all_bounds(self) -> Iterable[Tuple[int, int]]:
  """Equivalent to [(b.start, b.end) for b in self]."""
  prev = 0
@@ -965,7 +961,12 @@ class IRNode:
  was_forced: bool = attr.ib()
  index: Optional[int] = attr.ib(default=None)
 
- def copy(self, *, with_value: IRType) -> "IRNode":
+ def copy(
+ self,
+ *,
+ with_value: Optional[IRType] = None,
+ with_kwargs: Optional[IRKWargsType] = None,
+ ) -> "IRNode":
  # we may want to allow this combination in the future, but for now it's
  # a footgun.
  assert not self.was_forced, "modifying a forced node doesn't make sense"
@@ -974,8 +975,8 @@ def copy(self, *, with_value: IRType) -> "IRNode":
  # after copying.
  return IRNode(
  ir_type=self.ir_type,
- value=with_value,
- kwargs=self.kwargs,
+ value=self.value if with_value is None else with_value,
+ kwargs=self.kwargs if with_kwargs is None else with_kwargs,
  was_forced=self.was_forced,
  )
 
@@ -1048,6 +1049,16 @@ def __eq__(self, other):
  and self.was_forced == other.was_forced
  )
 
+ def __hash__(self):
+ return hash(
+ (
+ self.ir_type,
+ ir_value_key(self.ir_type, self.value),
+ ir_kwargs_key(self.ir_type, self.kwargs),
+ self.was_forced,
+ )
+ )
+
  def __repr__(self):
  # repr to avoid "BytesWarning: str() on a bytes instance" for bytes nodes
  forced_marker = " [forced]" if self.was_forced else ""
@@ -1087,22 +1098,36 @@ def ir_value_permitted(value, ir_type, kwargs):
  raise NotImplementedError(f"unhandled type {type(value)} of ir value {value}")
 
 
+def ir_value_key(ir_type, v):
+ if ir_type == "float":
+ return float_to_int(v)
+ return v
+
+
+def ir_kwargs_key(ir_type, kwargs):
+ if ir_type == "float":
+ return (
+ float_to_int(kwargs["min_value"]),
+ float_to_int(kwargs["max_value"]),
+ kwargs["allow_nan"],
+ kwargs["smallest_nonzero_magnitude"],
+ )
+ if ir_type == "integer":
+ return (
+ kwargs["min_value"],
+ kwargs["max_value"],
+ None if kwargs["weights"] is None else tuple(kwargs["weights"]),
+ kwargs["shrink_towards"],
+ )
+ return tuple(kwargs[key] for key in sorted(kwargs))
+
+
 def ir_value_equal(ir_type, v1, v2):
- if ir_type != "float":
- return v1 == v2
- return float_to_int(v1) == float_to_int(v2)
+ return ir_value_key(ir_type, v1) == ir_value_key(ir_type, v2)
 
 
 def ir_kwargs_equal(ir_type, kwargs1, kwargs2):
- if ir_type != "float":
- return kwargs1 == kwargs2
- return (
- float_to_int(kwargs1["min_value"]) == float_to_int(kwargs2["min_value"])
- and float_to_int(kwargs1["max_value"]) == float_to_int(kwargs2["max_value"])
- and kwargs1["allow_nan"] == kwargs2["allow_nan"]
- and kwargs1["smallest_nonzero_magnitude"]
- == kwargs2["smallest_nonzero_magnitude"]
- )
+ return ir_kwargs_key(ir_type, kwargs1) == ir_kwargs_key(ir_type, kwargs2)
 
 
 @dataclass_transform()
@@ -1115,16 +1140,25 @@ class ConjectureResult:
  status: Status = attr.ib()
  interesting_origin: Optional[InterestingOrigin] = attr.ib()
  buffer: bytes = attr.ib()
- blocks: Blocks = attr.ib()
+ # some ConjectureDatas pass through the ir and some pass through buffers.
+ # the ir does not drive its result through the buffer, which means blocks/examples
+ # may differ (I think for forced values?) even when the buffer is the same.
+ # I don't *think* anything was relying on anything but .buffer for result equality,
+ # though that assumption may be leaning on flakiness detection invariants.
+ #
+ # If we don't do this, multiple (semantically, but not pythonically) equivalent results
+ # get stored in the pareto front.
+ blocks: Blocks = attr.ib(eq=False)
  output: str = attr.ib()
  extra_information: Optional[ExtraInformation] = attr.ib()
  has_discards: bool = attr.ib()
  target_observations: TargetObservations = attr.ib()
  tags: FrozenSet[StructuralCoverageTag] = attr.ib()
  forced_indices: FrozenSet[int] = attr.ib(repr=False)
- examples: Examples = attr.ib(repr=False)
+ examples: Examples = attr.ib(repr=False, eq=False)
  arg_slices: Set[Tuple[int, int]] = attr.ib(repr=False)
  slice_comments: Dict[Tuple[int, int], str] = attr.ib(repr=False)
+ invalid_at: Optional[Tuple[IRTypeName, IRKWargsType]] = attr.ib(repr=False)
 
  index: int = attr.ib(init=False)
 
@@ -1977,6 +2011,7 @@ def __init__(
  self.extra_information = ExtraInformation()
 
  self.ir_tree_nodes = ir_tree_prefix
+ self.invalid_at: Optional[Tuple[IRTypeName, IRKWargsType]] = None
  self._node_index = 0
  self.start_example(TOP_LABEL)
 
@@ -2292,12 +2327,16 @@ def _pop_ir_tree_node(self, ir_type: IRTypeName, kwargs: IRKWargsType) -> IRNode
  # (in fact, it is possible that giving up early here results in more time
  # for useful shrinks to run).
  if node.ir_type != ir_type:
+ # needed for try_shrinking_nodes to see what node was *attempted*
+ # to be drawn.
+ self.invalid_at = (ir_type, kwargs)
  self.mark_invalid(f"(internal) want a {ir_type} but have a {node.ir_type}")
 
  # if a node has different kwargs (and so is misaligned), but has a value
  # that is allowed by the expected kwargs, then we can coerce this node
  # into an aligned one by using its value. It's unclear how useful this is.
  if not ir_value_permitted(node.value, node.ir_type, kwargs):
+ self.invalid_at = (ir_type, kwargs)
  self.mark_invalid(f"(internal) got a {ir_type} but outside the valid range")
 
  return node
@@ -2328,6 +2367,7 @@ def as_result(self) -> Union[ConjectureResult, _Overrun]:
  forced_indices=frozenset(self.forced_indices),
  arg_slices=self.arg_slices,
  slice_comments=self.slice_comments,
+ invalid_at=self.invalid_at,
  )
  assert self.__result is not None
  self.blocks.transfer_ownership(self.__result)

hypothesis-python/src/hypothesis/internal/conjecture/engine.py

@@ -186,6 +186,7 @@ def __init__(
  # shrinking where we need to know about the structure of the
  # executed test case.
  self.__data_cache = LRUReusedCache(CACHE_SIZE)
+ self.__data_cache_ir = LRUReusedCache(CACHE_SIZE)
 
  self.__pending_call_explanation = None
  self._switch_to_hypothesis_provider = False
@@ -239,10 +240,52 @@ def __stoppable_test_function(self, data):
  # correct engine.
  raise
 
- def ir_tree_to_data(self, ir_tree_nodes):
+ def _cache(self, data):
+ result = data.as_result()
+ # when we shrink, we try out of bounds things, which can lead to the same
+ # data.buffer having multiple outcomes. eg data.buffer=b'' is Status.OVERRUN
+ # in normal circumstances, but a data with
+ # ir_nodes=[integer -5 {min_value: 0, max_value: 10}] will also have
+ # data.buffer=b'' but will be Status.INVALID instead.
+ #
+ # I think this indicates that we should be mark_overrun internally in
+ # these cases instead? alternatively, we'll map Status.INVALID to Overrun
+ # when caching.
+ if data.invalid_at is not None:
+ assert data.status is Status.INVALID
+ result = Overrun
+ self.__data_cache[data.buffer] = result
+ self.__data_cache_ir[tuple(data.examples.ir_tree_nodes)] = result
+
+ def cached_test_function_ir(self, ir_tree_nodes):
+ key = tuple(ir_tree_nodes)
+ try:
+ return self.__data_cache_ir[key]
+ except KeyError:
+ pass
+
+ try:
+ trial_data = ConjectureData.for_ir_tree(ir_tree_nodes)
+ self.tree.simulate_test_function(trial_data)
+ except PreviouslyUnseenBehaviour:
+ pass
+ else:
+ trial_data.freeze()
+ try:
+ return self.__data_cache_ir[tuple(trial_data.examples.ir_tree_nodes)]
+ except KeyError:
+ pass
+
  data = ConjectureData.for_ir_tree(ir_tree_nodes)
- self.__stoppable_test_function(data)
- return data
+ self.test_function(data)
+ self._cache(data)
+ # This covers slightly different cases than caching `data`. If the ir
+ # nodes (1) are not in our cache, (2) are not in our DataTree, and (3)
+ # running `data` through the test function concludes before consuming
+ # all ir nodes (eg because of misaligned ir nodes), the initial ir nodes
+ # will not be cached and we may continue to miss them.
+ self.__data_cache_ir[key] = data.as_result()
+ return data.as_result()
 
  def test_function(self, data):
  if self.__pending_call_explanation is not None:
@@ -274,7 +317,7 @@ def test_function(self, data):
  ),
  }
  self.stats_per_test_case.append(call_stats)
- self.__data_cache[data.buffer] = data.as_result()
+ self._cache(data)
 
  self.debug_data(data)
 
@@ -321,8 +364,9 @@ def test_function(self, data):
 
  # drive the ir tree through the test function to convert it
  # to a buffer
- data = self.ir_tree_to_data(data.examples.ir_tree_nodes)
- self.__data_cache[data.buffer] = data.as_result()
+ data = ConjectureData.for_ir_tree(data.examples.ir_tree_nodes)
+ self.__stoppable_test_function(data)
+ self._cache(data)
 
  key = data.interesting_origin
  changed = False