🐛 Avoid stack overflow during shrinking of tuples

.yarn/versions/2ae83f1c.yml

@@ -0,0 +1,7 @@
+releases:
+  fast-check: patch
+
+declined:
+  - "@fast-check/ava"
+  - "@fast-check/jest"
+  - "@fast-check/worker"

packages/fast-check/src/arbitrary/_internals/TupleArbitrary.ts

@@ -4,6 +4,7 @@ import { cloneIfNeeded, cloneMethod, WithCloneMethod } from '../../check/symbols
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
 import { Value } from '../../check/arbitrary/definition/Value';
 import { safeMap, safePush, safeSlice } from '../../utils/globals';
+import { makeLazy } from '../../stream/LazyIterableIterator';
 
 const safeArrayIsArray = Array.isArray;
 const safeObjectDefineProperty = Object.defineProperty;
@@ -55,13 +56,18 @@ export function tupleShrink<Ts extends unknown[]>(
   let s = Stream.nil<TupleExtendedValue<Ts>>();
   const safeContext: TupleContext = safeArrayIsArray(context) ? context : [];
   for (let idx = 0; idx !== arbs.length; ++idx) {
-    const shrinksForIndex: Stream<TupleExtendedValue<Ts>> = arbs[idx]
-      .shrink(value[idx], safeContext[idx])
-      .map((v) => {
-        const nextValues: Value<unknown>[] = safeMap(value, (v, idx) => new Value(cloneIfNeeded(v), safeContext[idx]));
-        return [...safeSlice(nextValues, 0, idx), v, ...safeSlice(nextValues, idx + 1)];
-      })
-      .map((values) => tupleWrapper(values) as TupleExtendedValue<Ts>);
+    const shrinksForIndex: IterableIterator<TupleExtendedValue<Ts>> = makeLazy(() =>
+      arbs[idx]
+        .shrink(value[idx], safeContext[idx])
+        .map((v) => {
+          const nextValues: Value<unknown>[] = safeMap(
+            value,
+            (v, idx) => new Value(cloneIfNeeded(v), safeContext[idx])
+          );
+          return [...safeSlice(nextValues, 0, idx), v, ...safeSlice(nextValues, idx + 1)];
+        })
+        .map((values) => tupleWrapper(values) as TupleExtendedValue<Ts>)
+    );
     s = s.join(shrinksForIndex);
   }
   return s;

packages/fast-check/test/e2e/NoStackOverflowOnShrink.spec.ts

@@ -82,6 +82,23 @@ describe(`NoStackOverflowOnShrink (seed: ${seed})`, () => {
     expect(() => iterateOverShrunkValues(arb, value!)).not.toThrow();
   });
 
+  it('should not run into stack overflow while calling shrink on very large tuple', () => {
+    // We expect the depth used by this test to be greater than
+    // the maximal depth we computed before reaching a stack overflow
+    expect(maxDepthForArrays).toBeGreaterThan(callStackSizeWithMargin);
+
+    const mrng = new fc.Random(prand.xorshift128plus(seed));
+    const arb = fc.tuple<boolean[]>(...[...Array(maxDepthForArrays)].fill(fc.boolean()));
+    let value: fc.Value<boolean[]> | null = null;
+    while (value === null) {
+      const tempShrinkable = arb.generate(mrng, undefined);
+      if (tempShrinkable.value.length >= callStackSize) {
+        value = tempShrinkable;
+      }
+    }
+    expect(() => iterateOverShrunkValues(arb, value!)).not.toThrow();
+  });
+
   it('should not run into stack overflow while calling shrink on very large shuffled sub-arrays', () => {
     // We expect the depth used by this test to be greater than
     // the maximal depth we computed before reaching a stack overflow