Factor out UnkeyedValidPathInfo and test

This makes the path info serialisers ideomatic again, which allows me to
test them.

src/libstore/daemon.cc

@@ -819,7 +819,7 @@ static void performOp(TunnelLogger * logger, ref<Store> store,
         if (info) {
             if (GET_PROTOCOL_MINOR(clientVersion) >= 17)
                 to << 1;
-            WorkerProto::Serialise<ValidPathInfo>::write(*store, wconn, *info, false);
+            WorkerProto::write(*store, wconn, static_cast<const UnkeyedValidPathInfo &>(*info));
         } else {
             assert(GET_PROTOCOL_MINOR(clientVersion) >= 17);
             to << 0;

src/libstore/path-info.cc

@@ -3,6 +3,25 @@
 
 namespace nix {
 
+GENERATE_CMP_EXT(
+    ,
+    UnkeyedValidPathInfo,
+    me->deriver,
+    me->narHash,
+    me->references,
+    me->registrationTime,
+    me->narSize,
+    //me->id,
+    me->ultimate,
+    me->sigs,
+    me->ca);
+
+GENERATE_CMP_EXT(
+    ,
+    ValidPathInfo,
+    me->path,
+    static_cast<const UnkeyedValidPathInfo &>(*me));
+
 std::string ValidPathInfo::fingerprint(const Store & store) const
 {
     if (narSize == 0)
@@ -102,8 +121,8 @@ ValidPathInfo::ValidPathInfo(
     std::string_view name,
     ContentAddressWithReferences && ca,
     Hash narHash)
-      : path(store.makeFixedOutputPathFromCA(name, ca))
+      : UnkeyedValidPathInfo(narHash)
-      , narHash(narHash)
+      , path(store.makeFixedOutputPathFromCA(name, ca))
 {
     std::visit(overloaded {
         [this](TextInfo && ti) {

src/libstore/path-info.hh

@@ -32,9 +32,8 @@ struct SubstitutablePathInfo
 typedef std::map<StorePath, SubstitutablePathInfo> SubstitutablePathInfos;
 
 
-struct ValidPathInfo
+struct UnkeyedValidPathInfo
 {
-    StorePath path;
     std::optional<StorePath> deriver;
     /**
      * \todo document this
@@ -72,6 +71,20 @@ struct ValidPathInfo
      */
     std::optional<ContentAddress> ca;
 
+    UnkeyedValidPathInfo(const UnkeyedValidPathInfo & other) = default;
+
+    UnkeyedValidPathInfo(Hash narHash) : narHash(narHash) { };
+
+    DECLARE_CMP(UnkeyedValidPathInfo);
+
+    virtual ~UnkeyedValidPathInfo() { }
+};
+
+struct ValidPathInfo : UnkeyedValidPathInfo {
+    StorePath path;
+
+    DECLARE_CMP(ValidPathInfo);
+
     /**
      * Return a fingerprint of the store path to be used in binary
      * cache signatures. It contains the store path, the base-32
@@ -114,8 +127,8 @@ struct ValidPathInfo
 
     ValidPathInfo(const ValidPathInfo & other) = default;
 
-    ValidPathInfo(StorePath && path, Hash narHash) : path(std::move(path)), narHash(narHash) { };
+    ValidPathInfo(StorePath && path, UnkeyedValidPathInfo info) : UnkeyedValidPathInfo(info), path(std::move(path)) { };
-    ValidPathInfo(const StorePath & path, Hash narHash) : path(path), narHash(narHash) { };
+    ValidPathInfo(const StorePath & path, UnkeyedValidPathInfo info) : UnkeyedValidPathInfo(info), path(path) { };
 
     ValidPathInfo(const Store & store,
         std::string_view name, ContentAddressWithReferences && ca, Hash narHash);

src/libstore/remote-store.cc

@@ -332,7 +332,8 @@ void RemoteStore::queryPathInfoUncached(const StorePath & path,
                 if (!valid) throw InvalidPath("path '%s' is not valid", printStorePath(path));
             }
             info = std::make_shared<ValidPathInfo>(
-                WorkerProto::Serialise<ValidPathInfo>::read(*this, *conn, StorePath{path}));
+                StorePath{path},
+                WorkerProto::Serialise<UnkeyedValidPathInfo>::read(*this, *conn));
         }
         callback(std::move(info));
     } catch (...) { callback.rethrow(); }

src/libstore/tests/worker-protocol.cc

@@ -329,6 +329,159 @@ VERSIONED_CHARACTERIZATION_TEST(
         t;
     }))
 
+VERSIONED_CHARACTERIZATION_TEST(
+    WorkerProtoTest,
+    unkeyedValidPathInfo_1_15,
+    "unkeyed-valid-path-info-1.15",
+    1 << 8 | 15,
+    (std::tuple<UnkeyedValidPathInfo, UnkeyedValidPathInfo> {
+        ({
+            UnkeyedValidPathInfo info {
+                Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+            };
+            info.registrationTime = 23423;
+            info.narSize = 34878;
+            info;
+        }),
+        ({
+            UnkeyedValidPathInfo info {
+                Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+            };
+            info.deriver = StorePath {
+                "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
+            };
+            info.references = {
+                StorePath {
+                    "g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo.drv",
+                },
+            };
+            info.registrationTime = 23423;
+            info.narSize = 34878;
+            info;
+        }),
+    }))
+
+VERSIONED_CHARACTERIZATION_TEST(
+    WorkerProtoTest,
+    validPathInfo_1_15,
+    "valid-path-info-1.15",
+    1 << 8 | 15,
+    (std::tuple<ValidPathInfo, ValidPathInfo> {
+        ({
+            ValidPathInfo info {
+                StorePath {
+                    "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+                },
+                UnkeyedValidPathInfo {
+                    Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+                },
+            };
+            info.registrationTime = 23423;
+            info.narSize = 34878;
+            info;
+        }),
+        ({
+            ValidPathInfo info {
+                StorePath {
+                    "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+                },
+                UnkeyedValidPathInfo {
+                    Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+                },
+            };
+            info.deriver = StorePath {
+                "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
+            };
+            info.references = {
+                // other reference
+                StorePath {
+                    "g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo",
+                },
+                // self reference
+                StorePath {
+                    "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+                },
+            };
+            info.registrationTime = 23423;
+            info.narSize = 34878;
+            info;
+        }),
+    }))
+
+VERSIONED_CHARACTERIZATION_TEST(
+    WorkerProtoTest,
+    validPathInfo_1_16,
+    "valid-path-info-1.16",
+    1 << 8 | 16,
+    (std::tuple<ValidPathInfo, ValidPathInfo, ValidPathInfo> {
+        ({
+            ValidPathInfo info {
+                StorePath {
+                    "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+                },
+                UnkeyedValidPathInfo {
+                    Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+                },
+            };
+            info.registrationTime = 23423;
+            info.narSize = 34878;
+            info.ultimate = true;
+            info;
+        }),
+        ({
+            ValidPathInfo info {
+                StorePath {
+                    "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+                },
+                UnkeyedValidPathInfo {
+                    Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+                },
+            };
+            info.deriver = StorePath {
+                "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
+            };
+            info.references = {
+                // other reference
+                StorePath {
+                    "g1w7hyyyy1w7hy3qg1w7hy3qgqqqqy3q-foo",
+                },
+                // self reference
+                StorePath {
+                    "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+                },
+            };
+            info.registrationTime = 23423;
+            info.narSize = 34878;
+            info.sigs = {
+                "fake-sig-1",
+                "fake-sig-2",
+            },
+            info;
+        }),
+        ({
+            ValidPathInfo info {
+                *LibStoreTest::store,
+                "foo",
+                FixedOutputInfo {
+                    .method = FileIngestionMethod::Recursive,
+                    .hash = hashString(HashType::htSHA256, "(...)"),
+                    .references = {
+                        .others = {
+                            StorePath {
+                                "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+                            },
+                        },
+                        .self = true,
+                    },
+                },
+                Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+            };
+            info.registrationTime = 23423;
+            info.narSize = 34878;
+            info;
+        }),
+    }))
+
 VERSIONED_CHARACTERIZATION_TEST(
     WorkerProtoTest,
     optionalTrustedFlag,

src/libstore/worker-protocol.cc

@@ -145,14 +145,24 @@ void WorkerProto::Serialise<BuildResult>::write(const Store & store, WorkerProto
 ValidPathInfo WorkerProto::Serialise<ValidPathInfo>::read(const Store & store, ReadConn conn)
 {
     auto path = WorkerProto::Serialise<StorePath>::read(store, conn);
-    return WorkerProto::Serialise<ValidPathInfo>::read(store, conn, std::move(path));
+    return ValidPathInfo {
+        std::move(path),
+        WorkerProto::Serialise<UnkeyedValidPathInfo>::read(store, conn),
+    };
 }
 
-ValidPathInfo WorkerProto::Serialise<ValidPathInfo>::read(const Store & store, ReadConn conn, StorePath && path)
+void WorkerProto::Serialise<ValidPathInfo>::write(const Store & store, WriteConn conn, const ValidPathInfo & pathInfo)
+{
+    WorkerProto::write(store, conn, pathInfo.path);
+    WorkerProto::write(store, conn, static_cast<const UnkeyedValidPathInfo &>(pathInfo));
+}
+
+
+UnkeyedValidPathInfo WorkerProto::Serialise<UnkeyedValidPathInfo>::read(const Store & store, ReadConn conn)
 {
     auto deriver = readString(conn.from);
     auto narHash = Hash::parseAny(readString(conn.from), htSHA256);
-    ValidPathInfo info(path, narHash);
+    UnkeyedValidPathInfo info(narHash);
     if (deriver != "") info.deriver = store.parseStorePath(deriver);
     info.references = WorkerProto::Serialise<StorePathSet>::read(store, conn);
     conn.from >> info.registrationTime >> info.narSize;
@@ -164,14 +174,8 @@ ValidPathInfo WorkerProto::Serialise<ValidPathInfo>::read(const Store & store, R
     return info;
 }
 
-void WorkerProto::Serialise<ValidPathInfo>::write(
+void WorkerProto::Serialise<UnkeyedValidPathInfo>::write(const Store & store, WriteConn conn, const UnkeyedValidPathInfo & pathInfo)
-    const Store & store,
-    WriteConn conn,
-    const ValidPathInfo & pathInfo,
-    bool includePath)
 {
-    if (includePath)
-        conn.to << store.printStorePath(pathInfo.path);
     conn.to
         << (pathInfo.deriver ? store.printStorePath(*pathInfo.deriver) : "")
         << pathInfo.narHash.to_string(HashFormat::Base16, false);

src/libstore/worker-protocol.hh

@@ -32,6 +32,7 @@ struct DerivedPath;
 struct BuildResult;
 struct KeyedBuildResult;
 struct ValidPathInfo;
+struct UnkeyedValidPathInfo;
 enum TrustedFlag : bool;
 
 
@@ -207,6 +208,10 @@ DECLARE_WORKER_SERIALISER(BuildResult);
 template<>
 DECLARE_WORKER_SERIALISER(KeyedBuildResult);
 template<>
+DECLARE_WORKER_SERIALISER(ValidPathInfo);
+template<>
+DECLARE_WORKER_SERIALISER(UnkeyedValidPathInfo);
+template<>
 DECLARE_WORKER_SERIALISER(std::optional<TrustedFlag>);
 
 template<typename T>
@@ -221,15 +226,4 @@ template<typename K, typename V>
 DECLARE_WORKER_SERIALISER(std::map<K COMMA_ V>);
 #undef COMMA_
 
-/* These are a non-standard form for historical reasons. */
-
-template<>
-struct WorkerProto::Serialise<ValidPathInfo>
-{
-    static ValidPathInfo read(const Store & store, WorkerProto::ReadConn conn);
-    static ValidPathInfo read(const Store & store, WorkerProto::ReadConn conn, StorePath && path);
-
-    static void write(const Store & store, WriteConn conn, const ValidPathInfo & pathInfo, bool includePath = true);
-};
-
 }