💥 Drop deprecated big{U|}int{N|} (#5345)

**Description**

<!-- Please provide a short description and potentially linked issues
justifying the need for this PR -->

As planned in v3, we are dropping `bigUint`, `bigUintN` and `bigIntN` in
favor of `bigInt`.

<!-- * Your PR is fixing a bug or regression? Check for existing issues
related to this bug and link them -->
<!-- * Your PR is adding a new feature? Make sure there is a related
issue or discussion attached to it -->

<!-- You can provide any additional context to help into understanding
what's this PR is attempting to solve: reproduction of a bug, code
snippets... -->

**Checklist** — _Don't delete this checklist and make sure you do the
following before opening the PR_

- [x] The name of my PR follows [gitmoji](https://gitmoji.dev/)
specification
- [x] My PR references one of several related issues (if any)
- [x] New features or breaking changes must come with an associated
Issue or Discussion
- [x] My PR does not add any new dependency without an associated Issue
or Discussion
- [x] My PR includes bumps details, please run `yarn bump` and flag the
impacts properly
- [x] My PR adds relevant tests and they would have failed without my PR
(when applicable)

<!-- More about contributing at
https://github.com/dubzzz/fast-check/blob/main/CONTRIBUTING.md -->

**Advanced**

<!-- How to fill the advanced section is detailed below! -->

- [x] Category: 💥 Breaking Change
- [x] Impacts: As planned

<!-- [Category] Please use one of the categories below, it will help us
into better understanding the urgency of the PR -->
<!-- * ✨ Introduce new features -->
<!-- * 📝 Add or update documentation -->
<!-- * ✅ Add or update tests -->
<!-- * 🐛 Fix a bug -->
<!-- * 🏷️ Add or update types -->
<!-- * ⚡️ Improve performance -->
<!-- * _Other(s):_ ... -->

<!-- [Impacts] Please provide a comma separated list of the potential
impacts that might be introduced by this change -->
<!-- * Generated values: Can your change impact any of the existing
generators in terms of generated values, if so which ones? when? -->
<!-- * Shrink values: Can your change impact any of the existing
generators in terms of shrink values, if so which ones? when? -->
<!-- * Performance: Can it require some typings changes on user side?
Please give more details -->
<!-- * Typings: Is there a potential performance impact? In which cases?
-->

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

@@ -1,6 +1,6 @@
 import type { Random } from '../../random/generator/Random';
 import type { Stream } from '../../stream/Stream';
-import { bigUintN } from '../bigUintN';
+import { bigInt } from '../bigInt';
 import { Arbitrary } from '../../check/arbitrary/definition/Arbitrary';
 import { Value } from '../../check/arbitrary/definition/Value';
 import { makeLazy } from '../../stream/LazyIterableIterator';
@@ -51,7 +51,7 @@ export class MixedCaseArbitrary extends Arbitrary<string> {
     const chars = [...rawStringValue.value]; // split into valid unicode (keeps surrogate pairs)
     const togglePositions = computeTogglePositions(chars, this.toggleCase);
 
-    const flagsArb = bigUintN(togglePositions.length);
+    const flagsArb = bigInt(BigInt(0), (BigInt(1) << BigInt(togglePositions.length)) - BigInt(1));
     const flagsValue = flagsArb.generate(mrng, undefined); // true => toggle the char, false => keep it as-is
 
     applyFlagsOnChars(chars, flagsValue.value, togglePositions, this.toggleCase);
@@ -114,7 +114,7 @@ export class MixedCaseArbitrary extends Arbitrary<string> {
         makeLazy(() => {
           const chars = [...rawString];
           const togglePositions = computeTogglePositions(chars, this.toggleCase);
-          return bigUintN(togglePositions.length)
+          return bigInt(BigInt(0), (BigInt(1) << BigInt(togglePositions.length)) - BigInt(1))
             .shrink(flags, contextSafe.flagsContext)
             .map((nFlagsValue) => {
               const nChars = safeSlice(chars); // cloning chars

packages/fast-check/src/fast-check-default.ts

@@ -26,10 +26,6 @@ import type { ArrayConstraints } from './arbitrary/array';
 import { array } from './arbitrary/array';
 import type { BigIntConstraints } from './arbitrary/bigInt';
 import { bigInt } from './arbitrary/bigInt';
-import { bigIntN } from './arbitrary/bigIntN';
-import type { BigUintConstraints } from './arbitrary/bigUint';
-import { bigUint } from './arbitrary/bigUint';
-import { bigUintN } from './arbitrary/bigUintN';
 import { boolean } from './arbitrary/boolean';
 import type { FalsyContraints, FalsyValue } from './arbitrary/falsy';
 import { falsy } from './arbitrary/falsy';
@@ -251,7 +247,6 @@ export type {
   ArrayConstraints,
   BigIntConstraints,
   BigIntArrayConstraints,
-  BigUintConstraints,
   CommandsContraints,
   DateConstraints,
   DictionaryConstraints,
@@ -343,10 +338,7 @@ export {
   nat,
   maxSafeInteger,
   maxSafeNat,
-  bigIntN,
-  bigUintN,
   bigInt,
-  bigUint,
   mixedCase,
   string,
   base64String,

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

@@ -831,26 +831,6 @@ describe(`NoRegression`, () => {
       ),
     ).toThrowErrorMatchingSnapshot();
   });
-  it('bigIntN', () => {
-    expect(
-      runWithSanitizedStack(() =>
-        fc.assert(
-          fc.property(fc.bigIntN(100), (v) => testFunc(v)),
-          settings,
-        ),
-      ),
-    ).toThrowErrorMatchingSnapshot();
-  });
-  it('bigUintN', () => {
-    expect(
-      runWithSanitizedStack(() =>
-        fc.assert(
-          fc.property(fc.bigUintN(100), (v) => testFunc(v)),
-          settings,
-        ),
-      ),
-    ).toThrowErrorMatchingSnapshot();
-  });
   it('bigInt', () => {
     expect(
       runWithSanitizedStack(() =>
@@ -891,26 +871,6 @@ describe(`NoRegression`, () => {
       ),
     ).toThrowErrorMatchingSnapshot();
   });
-  it('bigUint', () => {
-    expect(
-      runWithSanitizedStack(() =>
-        fc.assert(
-          fc.property(fc.bigUint(), (v) => testFunc(v)),
-          settings,
-        ),
-      ),
-    ).toThrowErrorMatchingSnapshot();
-  });
-  it('bigUint({max})', () => {
-    expect(
-      runWithSanitizedStack(() =>
-        fc.assert(
-          fc.property(fc.bigUint({ max: BigInt(1) << BigInt(96) }), (v) => testFunc(v)),
-          settings,
-        ),
-      ),
-    ).toThrowErrorMatchingSnapshot();
-  });
   it('bigInt64Array', () => {
     expect(
       runWithSanitizedStack(() =>

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

@@ -34,10 +34,7 @@ describe(`Poisoning (seed: ${seed})`, () => {
     { name: 'maxSafeNat', arbitraryBuilder: () => fc.maxSafeNat() },
     { name: 'float', arbitraryBuilder: () => fc.float() },
     { name: 'double', arbitraryBuilder: () => fc.double() },
-    { name: 'bigIntN', arbitraryBuilder: () => fc.bigIntN(64) },
     { name: 'bigInt', arbitraryBuilder: () => fc.bigInt() },
-    { name: 'bigUintN', arbitraryBuilder: () => fc.bigUintN(64) },
-    { name: 'bigUint', arbitraryBuilder: () => fc.bigUint() },
     // String
     // : Multiple characters
     { name: 'base64String', arbitraryBuilder: () => fc.base64String() },

packages/fast-check/test/e2e/arbitraries/ArrayArbitrary.spec.ts

@@ -30,7 +30,7 @@ describe(`ArrayArbitrary (seed: ${seed})`, () => {
       expect(out.counterexample).toEqual([[5, 5]]);
     });
     biasIts('integer', fc.integer());
-    biasIts('bigint', fc.bigIntN(64));
+    biasIts('bigint', fc.bigInt());
   });
 });
 

packages/fast-check/test/e2e/arbitraries/BigIntArbitrary.spec.ts

@@ -4,11 +4,18 @@ import { seed } from '../seed';
 
 declare function BigInt(n: number | bigint | string): bigint;
 
+function bigInt1030() {
+  const n = 1030;
+  const min = BigInt(-1) << BigInt(n - 1);
+  const max = (BigInt(1) << BigInt(n - 1)) - BigInt(1);
+  return fc.bigInt({ min, max });
+}
+
 describe(`BigIntArbitrary (seed: ${seed})`, () => {
   describe('bitIntN', () => {
     it('Should be able to generate bigint above the highest positive double', () => {
       const out = fc.check(
-        fc.property(fc.bigIntN(1030), (v) => Number(v) !== Number.POSITIVE_INFINITY),
+        fc.property(bigInt1030(), (v) => Number(v) !== Number.POSITIVE_INFINITY),
         { seed: seed },
       );
       expect(out.failed).toBe(true);
@@ -19,7 +26,7 @@ describe(`BigIntArbitrary (seed: ${seed})`, () => {
     });
     it('Should be able to generate bigint below the smallest negative double', () => {
       const out = fc.check(
-        fc.property(fc.bigIntN(1030), (v) => Number(v) !== Number.NEGATIVE_INFINITY),
+        fc.property(bigInt1030(), (v) => Number(v) !== Number.NEGATIVE_INFINITY),
         { seed: seed },
       );
       expect(out.failed).toBe(true);
@@ -30,10 +37,7 @@ describe(`BigIntArbitrary (seed: ${seed})`, () => {
     });
     it('Should be able to generate small bigint (relatively to maximal bigint asked)', () => {
       const out = fc.check(
-        fc.property(
-          fc.bigIntN(1030),
-          (v) => Number(v) < Number.MIN_SAFE_INTEGER || Number(v) > Number.MAX_SAFE_INTEGER,
-        ),
+        fc.property(bigInt1030(), (v) => Number(v) < Number.MIN_SAFE_INTEGER || Number(v) > Number.MAX_SAFE_INTEGER),
         { seed: seed },
       );
       expect(out.failed).toBe(true);
@@ -46,7 +50,7 @@ describe(`BigIntArbitrary (seed: ${seed})`, () => {
     it('Should be able to generate close to min or max bigints (relatively to the asked range)', () => {
       const out = fc.check(
         fc.property(
-          fc.bigIntN(1030),
+          bigInt1030(),
           (v) =>
             v >= (BigInt(-1) << BigInt(1030 - 1)) + BigInt(500) && v <= (BigInt(1) << BigInt(1030 - 1)) - BigInt(500),
         ),
@@ -61,7 +65,7 @@ describe(`BigIntArbitrary (seed: ${seed})`, () => {
     it('Should not be able to generate small bigint if not biased (very improbable)', () => {
       const out = fc.check(
         fc.property(
-          fc.noBias(fc.bigIntN(1030)),
+          fc.noBias(bigInt1030()),
           (v) => Number(v) < Number.MIN_SAFE_INTEGER || Number(v) > Number.MAX_SAFE_INTEGER,
         ),
         { seed: seed },
@@ -71,7 +75,7 @@ describe(`BigIntArbitrary (seed: ${seed})`, () => {
     it('Should not be able to generate close to min or max bigints if not biased (very improbable)', () => {
       const out = fc.check(
         fc.property(
-          fc.noBias(fc.bigIntN(1030)),
+          fc.noBias(bigInt1030()),
           (v) =>
             v >= (BigInt(-1) << BigInt(1030 - 1)) + BigInt(500) && v <= (BigInt(1) << BigInt(1030 - 1)) - BigInt(500),
         ),

packages/fast-check/test/unit/arbitrary/_internals/BigIntArbitrary.spec.ts

@@ -246,8 +246,8 @@ describe('BigIntArbitrary (integration)', () => {
       fc.assert(
         fc.property(
           fc.bigInt(),
-          fc.bigUint({ max: BigInt(20) }), // larger trees might be too wide
-          fc.bigUint({ max: BigInt(20) }),
+          fc.bigInt({ min: BigInt(0), max: BigInt(20) }), // larger trees might be too wide
+          fc.bigInt({ min: BigInt(0), max: BigInt(20) }),
           (start, o1, o2) => {
             // Arrange
             const min = start;
@@ -276,10 +276,10 @@ describe('BigIntArbitrary (integration)', () => {
     it('should build an offset version of the shrinking tree if we offset all the values (keep every value >=0)', () =>
       fc.assert(
         fc.property(
-          fc.bigUint(),
-          fc.bigUint({ max: BigInt(20) }), // larger trees might be too wide
-          fc.bigUint({ max: BigInt(20) }),
-          fc.bigUint(),
+          fc.bigInt({ min: BigInt(0) }),
+          fc.bigInt({ min: BigInt(0), max: BigInt(20) }), // larger trees might be too wide
+          fc.bigInt({ min: BigInt(0), max: BigInt(20) }),
+          fc.bigInt({ min: BigInt(0) }),
           (start, o1, o2, offset) => {
             // Arrange
             fc.pre(start + o1 + offset <= Number.MAX_SAFE_INTEGER);