rapidcheck: change to working arbitrary instances

Here we're switching to combinators instead of dereference operator.
It turns out the dereference operator was being executed upon test
setup, meaning that we were only using a only single value for each of
the executions of the property tests! Really not good.

And on Windows, we instead get:

    operator* is not allowed in this context

ff6af6fc68/src/gen/detail/GenerationHandler.cpp (L16C31-L16C71)

Now a few of the property tests fail, because we're generating cases
which haven't been exercised before.

src/libexpr-test-support/tests/value/context.cc

@@ -8,23 +8,32 @@ using namespace nix;
 
 Gen<NixStringContextElem::DrvDeep> Arbitrary<NixStringContextElem::DrvDeep>::arbitrary()
 {
-    return gen::just(NixStringContextElem::DrvDeep {
+    return gen::map(gen::arbitrary<StorePath>(), [](StorePath drvPath) {
-        .drvPath = *gen::arbitrary<StorePath>(),
+        return NixStringContextElem::DrvDeep{
+            .drvPath = drvPath,
+        };
     });
 }
 
 Gen<NixStringContextElem> Arbitrary<NixStringContextElem>::arbitrary()
 {
-    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<NixStringContextElem::Raw>)) {
+    return gen::mapcat(
+        gen::inRange<uint8_t>(0, std::variant_size_v<NixStringContextElem::Raw>),
+        [](uint8_t n) -> Gen<NixStringContextElem> {
+            switch (n) {
             case 0:
-        return gen::just<NixStringContextElem>(*gen::arbitrary<NixStringContextElem::Opaque>());
+                return gen::map(
+                    gen::arbitrary<NixStringContextElem::Opaque>(), [](NixStringContextElem a) { return a; });
             case 1:
-        return gen::just<NixStringContextElem>(*gen::arbitrary<NixStringContextElem::DrvDeep>());
+                return gen::map(
+                    gen::arbitrary<NixStringContextElem::DrvDeep>(), [](NixStringContextElem a) { return a; });
             case 2:
-        return gen::just<NixStringContextElem>(*gen::arbitrary<NixStringContextElem::Built>());
+                return gen::map(
+                    gen::arbitrary<NixStringContextElem::Built>(), [](NixStringContextElem a) { return a; });
             default:
                 assert(false);
             }
+        });
 }
 
 }

src/libstore-test-support/tests/derived-path.cc

@@ -9,49 +9,63 @@ using namespace nix;
 
 Gen<SingleDerivedPath::Opaque> Arbitrary<SingleDerivedPath::Opaque>::arbitrary()
 {
-    return gen::just(DerivedPath::Opaque {
+    return gen::map(gen::arbitrary<StorePath>(), [](StorePath path) {
-        .path = *gen::arbitrary<StorePath>(),
+        return DerivedPath::Opaque{
+            .path = path,
+        };
     });
 }
 
 Gen<SingleDerivedPath::Built> Arbitrary<SingleDerivedPath::Built>::arbitrary()
 {
-    return gen::just(SingleDerivedPath::Built {
+    return gen::mapcat(gen::arbitrary<SingleDerivedPath>(), [](SingleDerivedPath drvPath) {
-        .drvPath = make_ref<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath>()),
+        return gen::map(gen::arbitrary<StorePathName>(), [drvPath](StorePathName outputPath) {
-        .output = (*gen::arbitrary<StorePathName>()).name,
+            return SingleDerivedPath::Built{
+                .drvPath = make_ref<SingleDerivedPath>(drvPath),
+                .output = outputPath.name,
+            };
+        });
     });
 }
 
 Gen<DerivedPath::Built> Arbitrary<DerivedPath::Built>::arbitrary()
 {
-    return gen::just(DerivedPath::Built {
+    return gen::mapcat(gen::arbitrary<SingleDerivedPath>(), [](SingleDerivedPath drvPath) {
-        .drvPath = make_ref<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath>()),
+        return gen::map(gen::arbitrary<OutputsSpec>(), [drvPath](OutputsSpec outputs) {
-        .outputs = *gen::arbitrary<OutputsSpec>(),
+            return DerivedPath::Built{
+                .drvPath = make_ref<SingleDerivedPath>(drvPath),
+                .outputs = outputs,
+            };
+        });
     });
 }
 
 Gen<SingleDerivedPath> Arbitrary<SingleDerivedPath>::arbitrary()
 {
-    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<SingleDerivedPath::Raw>)) {
+    return gen::mapcat(gen::inRange<uint8_t>(0, std::variant_size_v<SingleDerivedPath::Raw>), [](uint8_t n) {
+        switch (n) {
         case 0:
-        return gen::just<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath::Opaque>());
+            return gen::map(gen::arbitrary<SingleDerivedPath::Opaque>(), [](SingleDerivedPath a) { return a; });
         case 1:
-        return gen::just<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath::Built>());
+            return gen::map(gen::arbitrary<SingleDerivedPath::Built>(), [](SingleDerivedPath a) { return a; });
         default:
             assert(false);
         }
+    });
 }
 
 Gen<DerivedPath> Arbitrary<DerivedPath>::arbitrary()
 {
-    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<DerivedPath::Raw>)) {
+    return gen::mapcat(gen::inRange<uint8_t>(0, std::variant_size_v<DerivedPath::Raw>), [](uint8_t n) {
+        switch (n) {
         case 0:
-        return gen::just<DerivedPath>(*gen::arbitrary<DerivedPath::Opaque>());
+            return gen::map(gen::arbitrary<DerivedPath::Opaque>(), [](DerivedPath a) { return a; });
         case 1:
-        return gen::just<DerivedPath>(*gen::arbitrary<DerivedPath::Built>());
+            return gen::map(gen::arbitrary<DerivedPath::Built>(), [](DerivedPath a) { return a; });
         default:
             assert(false);
         }
+    });
 }
 
 }

src/libstore-test-support/tests/outputs-spec.cc

@@ -7,18 +7,20 @@ using namespace nix;
 
 Gen<OutputsSpec> Arbitrary<OutputsSpec>::arbitrary()
 {
-    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<OutputsSpec::Raw>)) {
+    return gen::mapcat(
+        gen::inRange<uint8_t>(0, std::variant_size_v<OutputsSpec::Raw>), [](uint8_t n) -> Gen<OutputsSpec> {
+            switch (n) {
             case 0:
-        return gen::just((OutputsSpec) OutputsSpec::All { });
+                return gen::just((OutputsSpec) OutputsSpec::All{});
             case 1:
-        return gen::just((OutputsSpec) OutputsSpec::Names {
+                return gen::map(
-            *gen::nonEmpty(gen::container<StringSet>(gen::map(
+                    gen::nonEmpty(gen::container<StringSet>(
-                gen::arbitrary<StorePathName>(),
+                        gen::map(gen::arbitrary<StorePathName>(), [](StorePathName n) { return n.name; }))),
-                [](StorePathName n) { return n.name; }))),
+                    [](StringSet names) { return (OutputsSpec) OutputsSpec::Names{names}; });
-        });
             default:
                 assert(false);
             }
+        });
 }
 
 }