CHANGELOG.md

@@ -1,3 +1,17 @@
+# 2.6.0
+
+_Towards a uniform way to constrain arbitraries - step 3: number arbitraries_
+[[Code](https://github.com/dubzzz/fast-check/tree/v2.6.0)][[Diff](https://github.com/dubzzz/fast-check/compare/v2.5.0...v2.6.0)]
+
+## Features
+
+- ([PR#1067](https://github.com/dubzzz/fast-check/pull/1067)) Unify signatures on arbitraries: fc.bigInt and fc.bigUint (see [#992](https://github.com/dubzzz/fast-check/issues/992))
+- ([PR#1068](https://github.com/dubzzz/fast-check/pull/1068)) Unify signatures on arbitraries: fc.float and fc.double (see [#992](https://github.com/dubzzz/fast-check/issues/992))
+- ([PR#1076](https://github.com/dubzzz/fast-check/pull/1076)) Unify signatures on arbitraries: fc.integer and fc.nat (see [#992](https://github.com/dubzzz/fast-check/issues/992))
+- ([PR#1080](https://github.com/dubzzz/fast-check/pull/1080)) Mark old signatures as deprecated (see [#992](https://github.com/dubzzz/fast-check/issues/992))
+
+---
+
 # 2.5.0
 
 _Towards a uniform way to constrain arbitraries - step 2: remaining arbitraries except number related ones_

codemods/unify-signatures/snippet-5.js

@@ -70,3 +70,46 @@ fc.lorem(10, false);
 fc.lorem(10, something);
 fc.lorem(num, something);
 fc.lorem({ maxCount: 10 });
+
+// bigInt
+
+fc.bigInt();
+fc.bigInt(1n, 3n);
+fc.bigInt(BigInt(1), BigInt(3));
+fc.bigInt({ min: 1n, max: 3n });
+
+// bigUint
+
+fc.bigUint();
+fc.bigUint(3n);
+fc.bigUint(BigInt(3));
+fc.bigUint({ max: 3n });
+
+// float
+
+fc.float();
+fc.float(1.0);
+fc.float(2.0);
+fc.float(0.0, 1.0);
+fc.float(0.0, 2.0);
+fc.float(-1.0, 1.0);
+fc.float(-1.0, 2.0);
+fc.float({ min: -1.0, max: 2.0 });
+
+// nat
+
+fc.nat();
+fc.nat(10);
+fc.nat(0x7fffffff);
+fc.nat(2147483647);
+
+// integer
+
+fc.integer();
+fc.integer(10);
+fc.integer(0x7fffffff);
+fc.integer(2147483647);
+fc.integer(-1, 10);
+fc.integer(-0x80000000, 0x7fffffff);
+fc.integer(-2147483648, 2147483647);
+fc.integer({ min: -1, max: 1 });

codemods/unify-signatures/transform.cjs

@@ -154,6 +154,11 @@ module.exports = function (file, api, options) {
   }
 
   function isNumericValue(argument, value) {
+    if (value < 0) {
+      return (
+        argument.type === 'UnaryExpression' && argument.operator === '-' && isNumericValue(argument.argument, -value)
+      );
+    }
     return isNumeric(argument) && argument.value === value;
   }
   function getArrayLength(argument) {
@@ -349,6 +354,85 @@ module.exports = function (file, api, options) {
           }
           break;
         }
+        case 'bigInt': {
+          if (p.value.arguments.length === 2) {
+            // fc.bigInt(min, max) -> fc.bigInt({min, max})
+            p.value.arguments = computeNewArguments(
+              [],
+              [
+                j.property('init', j.identifier('min'), p.value.arguments[0]),
+                j.property('init', j.identifier('max'), p.value.arguments[1]),
+              ]
+            );
+          }
+          break;
+        }
+        case 'bigUint': {
+          if (p.value.arguments.length === 1 && p.value.arguments[0].type !== 'ObjectExpression') {
+            // fc.bigUint(max) -> fc.bigUint({max})
+            p.value.arguments = computeNewArguments(
+              [],
+              [j.property('init', j.identifier('max'), p.value.arguments[0])]
+            );
+          }
+          break;
+        }
+        case 'double':
+        case 'float': {
+          if (p.value.arguments.length === 1 && p.value.arguments[0].type !== 'ObjectExpression') {
+            // fc.float(max) -> fc.float({max})
+            const simplifyMax = options.simplifyMax && isNumericValue(p.value.arguments[0], 1.0);
+            p.value.arguments = computeNewArguments(
+              [],
+              [!simplifyMax && j.property('init', j.identifier('max'), p.value.arguments[0])]
+            );
+          } else if (p.value.arguments.length === 2) {
+            // fc.float(min, max) -> fc.float({min, max})
+            const simplifyMin = options.simplifyMin && isNumericValue(p.value.arguments[0], 0.0);
+            const simplifyMax = options.simplifyMax && isNumericValue(p.value.arguments[1], 1.0);
+            p.value.arguments = computeNewArguments(
+              [],
+              [
+                !simplifyMin && j.property('init', j.identifier('min'), p.value.arguments[0]),
+                !simplifyMax && j.property('init', j.identifier('max'), p.value.arguments[1]),
+              ]
+            );
+          }
+          break;
+        }
+        case 'nat': {
+          if (p.value.arguments.length === 1 && p.value.arguments[0].type !== 'ObjectExpression') {
+            // fc.nat(max) -> fc.nat({max})
+            const simplifyMax = options.simplifyMax && isNumericValue(p.value.arguments[0], 0x7fffffff);
+            p.value.arguments = computeNewArguments(
+              [],
+              [!simplifyMax && j.property('init', j.identifier('max'), p.value.arguments[0])]
+            );
+          }
+          break;
+        }
+        case 'integer': {
+          if (p.value.arguments.length === 1 && p.value.arguments[0].type !== 'ObjectExpression') {
+            // fc.integer(max) -> fc.integer({max})
+            const simplifyMax = options.simplifyMax && isNumericValue(p.value.arguments[0], 0x7fffffff);
+            p.value.arguments = computeNewArguments(
+              [],
+              [!simplifyMax && j.property('init', j.identifier('max'), p.value.arguments[0])]
+            );
+          } else if (p.value.arguments.length === 2) {
+            // fc.integer(min, max) -> fc.integer({min, max})
+            const simplifyMin = options.simplifyMin && isNumericValue(p.value.arguments[0], -0x80000000);
+            const simplifyMax = options.simplifyMax && isNumericValue(p.value.arguments[1], 0x7fffffff);
+            p.value.arguments = computeNewArguments(
+              [],
+              [
+                !simplifyMin && j.property('init', j.identifier('min'), p.value.arguments[0]),
+                !simplifyMax && j.property('init', j.identifier('max'), p.value.arguments[1]),
+              ]
+            );
+          }
+          break;
+        }
       }
       return p;
     })