Use StorePathDescriptor much more wildly

perl/lib/Nix/Store.xs

@@ -80,7 +80,7 @@ SV * queryReferences(char * path)
 SV * queryPathHash(char * path)
     PPCODE:
         try {
-            auto s = store()->queryPathInfo(store()->parseStorePath(path))->narHash.to_string(Base32, true);
+            auto s = store()->queryPathInfo(store()->parseStorePath(path))->narHash->to_string(Base32, true);
             XPUSHs(sv_2mortal(newSVpv(s.c_str(), 0)));
         } catch (Error & e) {
             croak("%s", e.what());
@@ -106,7 +106,7 @@ SV * queryPathInfo(char * path, int base32)
                 XPUSHs(&PL_sv_undef);
             else
                 XPUSHs(sv_2mortal(newSVpv(store()->printStorePath(*info->deriver).c_str(), 0)));
-            auto s = info->narHash.to_string(base32 ? Base32 : Base16, true);
+            auto s = info->narHash->to_string(base32 ? Base32 : Base16, true);
             XPUSHs(sv_2mortal(newSVpv(s.c_str(), 0)));
             mXPUSHi(info->registrationTime);
             mXPUSHi(info->narSize);
@@ -224,7 +224,7 @@ SV * hashString(char * algo, int base32, char * s)
 SV * convertHash(char * algo, char * s, int toBase32)
     PPCODE:
         try {
-            Hash h(s, parseHashType(algo));
+            auto h = Hash::parseAny(s, parseHashType(algo));
             string s = h.to_string(toBase32 ? Base32 : Base16, false);
             XPUSHs(sv_2mortal(newSVpv(s.c_str(), 0)));
         } catch (Error & e) {
@@ -285,7 +285,7 @@ SV * addToStore(char * srcPath, int recursive, char * algo)
 SV * makeFixedOutputPath(int recursive, char * algo, char * hash, char * name)
     PPCODE:
         try {
-            Hash h(hash, parseHashType(algo));
+            auto h = Hash::parseAny(hash, parseHashType(algo));
             auto method = recursive ? FileIngestionMethod::Recursive : FileIngestionMethod::Flat;
             auto path = store()->makeFixedOutputPath(name, FixedOutputInfo {
                 {

src/build-remote/build-remote.cc

@@ -253,8 +253,11 @@ static int _main(int argc, char * * argv)
             throw Error("build of '%s' on '%s' failed: %s", store->printStorePath(*drvPath), storeUri, result.errorMsg);
 
         StorePathSet missing;
-        for (auto & path : outputs)
-            if (!store->isValidPath(store->parseStorePath(path))) missing.insert(store->parseStorePath(path));
+        for (auto & path : outputs) {
+            auto storePath = store->parseStorePath(path);
+            if (!store->isValidPath(storePath))
+                missing.insert(store->parseStorePath(path));
+        }
 
         if (!missing.empty()) {
             Activity act(*logger, lvlTalkative, actUnknown, fmt("copying outputs from '%s'", storeUri));

src/libexpr/common-eval-args.cc

@@ -75,8 +75,9 @@ Path lookupFileArg(EvalState & state, string s)
 {
     if (isUri(s)) {
         return state.store->toRealPath(
-            fetchers::downloadTarball(
-                state.store, resolveUri(s), "source", false).first.storePath);
+            state.store->makeFixedOutputPathFromCA(
+                fetchers::downloadTarball(
+                    state.store, resolveUri(s), "source", false).first.storePath));
     } else if (s.size() > 2 && s.at(0) == '<' && s.at(s.size() - 1) == '>') {
         Path p = s.substr(1, s.size() - 2);
         return state.findFile(p);

src/libexpr/eval-cache.cc

@@ -285,11 +285,10 @@ static std::shared_ptr<AttrDb> makeAttrDb(const Hash & fingerprint)
 }
 
 EvalCache::EvalCache(
-    bool useCache,
-    const Hash & fingerprint,
+    std::optional<std::reference_wrapper<const Hash>> useCache,
     EvalState & state,
     RootLoader rootLoader)
-    : db(useCache ? makeAttrDb(fingerprint) : nullptr)
+    : db(useCache ? makeAttrDb(*useCache) : nullptr)
     , state(state)
     , rootLoader(rootLoader)
 {

src/libexpr/eval-cache.hh

@@ -4,6 +4,7 @@
 #include "hash.hh"
 #include "eval.hh"
 
+#include <functional>
 #include <variant>
 
 namespace nix::eval_cache {
@@ -26,8 +27,7 @@ class EvalCache : public std::enable_shared_from_this<EvalCache>
 public:
 
     EvalCache(
-        bool useCache,
-        const Hash & fingerprint,
+        std::optional<std::reference_wrapper<const Hash>> useCache,
         EvalState & state,
         RootLoader rootLoader);
 

src/libexpr/flake/flake.cc

@@ -61,7 +61,7 @@ static std::tuple<fetchers::Tree, FlakeRef, FlakeRef> fetchOrSubstituteTree(
     auto [tree, lockedRef] = fetched.value();
 
     debug("got tree '%s' from '%s'",
-        state.store->printStorePath(tree.storePath), lockedRef);
+        state.store->printStorePath(state.store->makeFixedOutputPathFromCA(tree.storePath)), lockedRef);
 
     if (state.allowedPaths)
         state.allowedPaths->insert(tree.actualPath);
@@ -179,7 +179,8 @@ static Flake getFlake(
     auto flakeFile = canonPath(sourceInfo.actualPath + "/" + lockedRef.subdir + "/flake.nix");
     if (!isInDir(flakeFile, sourceInfo.actualPath))
         throw Error("'flake.nix' file of flake '%s' escapes from '%s'",
-            lockedRef, state.store->printStorePath(sourceInfo.storePath));
+            lockedRef,
+            state.store->printStorePath(state.store->makeFixedOutputPathFromCA(sourceInfo.storePath)));
 
     Flake flake {
         .originalRef = originalRef,
@@ -591,14 +592,14 @@ static RegisterPrimOp r2("__getFlake", 1, prim_getFlake, "flakes");
 
 }
 
-Fingerprint LockedFlake::getFingerprint() const
+Fingerprint LockedFlake::getFingerprint(const Store & store) const
 {
     // FIXME: as an optimization, if the flake contains a lock file
     // and we haven't changed it, then it's sufficient to use
     // flake.sourceInfo.storePath for the fingerprint.
     return hashString(htSHA256,
         fmt("%s;%d;%d;%s",
-            flake.sourceInfo->storePath.to_string(),
+            store.makeFixedOutputPathFromCA(flake.sourceInfo->storePath).to_string(),
             flake.lockedRef.input.getRevCount().value_or(0),
             flake.lockedRef.input.getLastModified().value_or(0),
             lockFile));

src/libexpr/flake/flake.hh

@@ -48,7 +48,7 @@ struct LockedFlake
     Flake flake;
     LockFile lockFile;
 
-    Fingerprint getFingerprint() const;
+    Fingerprint getFingerprint(const Store & store) const;
 };
 
 struct LockFlags

src/libexpr/flake/lockfile.cc

@@ -36,7 +36,7 @@ LockedNode::LockedNode(const nlohmann::json & json)
         throw Error("lockfile contains mutable lock '%s'", attrsToJson(lockedRef.input.toAttrs()));
 }
 
-StorePath LockedNode::computeStorePath(Store & store) const
+StorePathDescriptor LockedNode::computeStorePath(Store & store) const
 {
     return lockedRef.input.computeStorePath(store);
 }

src/libexpr/flake/lockfile.hh

@@ -1,6 +1,7 @@
 #pragma once
 
 #include "flakeref.hh"
+#include "content-address.hh"
 
 #include <nlohmann/json_fwd.hpp>
 
@@ -44,7 +45,7 @@ struct LockedNode : Node
 
     LockedNode(const nlohmann::json & json);
 
-    StorePath computeStorePath(Store & store) const;
+    StorePathDescriptor computeStorePath(Store & store) const;
 };
 
 struct LockFile

src/libexpr/parser.y

@@ -718,8 +718,15 @@ std::pair<bool, std::string> EvalState::resolveSearchPathElem(const SearchPathEl
 
     if (isUri(elem.second)) {
         try {
-            res = { true, store->toRealPath(fetchers::downloadTarball(
-                        store, resolveUri(elem.second), "source", false).first.storePath) };
+            res = {
+                true,
+                store->toRealPath(store->makeFixedOutputPathFromCA(
+                    fetchers::downloadTarball(
+                        store,
+                        resolveUri(elem.second),
+                        "source",
+                        false).first.storePath)),
+            };
         } catch (FileTransferError & e) {
             logWarning({
                 .name = "Entry download",

src/libexpr/primops.cc

@@ -91,7 +91,13 @@ static void prim_scopedImport(EvalState & state, const Pos & pos, Value * * args
     Path realPath = state.checkSourcePath(state.toRealPath(path, context));
 
     // FIXME
-    if (state.store->isStorePath(path) && state.store->isValidPath(state.store->parseStorePath(path)) && isDerivation(path)) {
+    auto complicatedCondition = [&]() -> bool {
+        if (!state.store->isStorePath(path))
+            return false;
+        auto path2 = state.store->parseStorePath(path);
+        return state.store->isValidPath(path2) && isDerivation(path);
+    };
+    if (complicatedCondition()) {
         Derivation drv = readDerivation(*state.store, realPath);
         Value & w = *state.allocValue();
         state.mkAttrs(w, 3 + drv.outputs.size());
@@ -1117,7 +1123,7 @@ static void prim_toFile(EvalState & state, const Pos & pos, Value * * args, Valu
 
 
 static void addPath(EvalState & state, const Pos & pos, const string & name, const Path & path_,
-    Value * filterFun, FileIngestionMethod method, const Hash & expectedHash, Value & v)
+    Value * filterFun, FileIngestionMethod method, const std::optional<Hash> expectedHash, Value & v)
 {
     const auto path = evalSettings.pureEval && expectedHash ?
         path_ :
@@ -1151,7 +1157,7 @@ static void addPath(EvalState & state, const Pos & pos, const string & name, con
         expectedStorePath = state.store->makeFixedOutputPath(name, FixedOutputInfo {
             {
                 .method = method,
-                .hash = expectedHash,
+                .hash = *expectedHash,
             },
             {},
         });
@@ -1188,7 +1194,7 @@ static void prim_filterSource(EvalState & state, const Pos & pos, Value * * args
             .errPos = pos
         });
 
-    addPath(state, pos, std::string(baseNameOf(path)), path, args[0], FileIngestionMethod::Recursive, Hash(), v);
+    addPath(state, pos, std::string(baseNameOf(path)), path, args[0], FileIngestionMethod::Recursive, std::nullopt, v);
 }
 
 static void prim_path(EvalState & state, const Pos & pos, Value * * args, Value & v)
@@ -1198,7 +1204,7 @@ static void prim_path(EvalState & state, const Pos & pos, Value * * args, Value
     string name;
     Value * filterFun = nullptr;
     auto method = FileIngestionMethod::Recursive;
-    Hash expectedHash;
+    Hash expectedHash(htSHA256);
 
     for (auto & attr : *args[0]->attrs) {
         const string & n(attr.name);

src/libexpr/primops/context.cc

@@ -150,8 +150,10 @@ static void prim_appendContext(EvalState & state, const Pos & pos, Value * * arg
                 .hint = hintfmt("Context key '%s' is not a store path", i.name),
                 .errPos = *i.pos
             });
-        if (!settings.readOnlyMode)
-            state.store->ensurePath(state.store->parseStorePath(i.name));
+        if (!settings.readOnlyMode) {
+            auto path = state.store->parseStorePath(i.name);
+            state.store->ensurePath(path);
+        }
         state.forceAttrs(*i.value, *i.pos);
         auto iter = i.value->attrs->find(sPath);
         if (iter != i.value->attrs->end()) {

src/libexpr/primops/fetchGit.cc

@@ -29,7 +29,7 @@ static void prim_fetchGit(EvalState & state, const Pos & pos, Value * * args, Va
             else if (n == "ref")
                 ref = state.forceStringNoCtx(*attr.value, *attr.pos);
             else if (n == "rev")
-                rev = Hash(state.forceStringNoCtx(*attr.value, *attr.pos), htSHA1);
+                rev = Hash::parseAny(state.forceStringNoCtx(*attr.value, *attr.pos), htSHA1);
             else if (n == "name")
                 name = state.forceStringNoCtx(*attr.value, *attr.pos);
             else if (n == "submodules")
@@ -69,7 +69,8 @@ static void prim_fetchGit(EvalState & state, const Pos & pos, Value * * args, Va
     auto [tree, input2] = input.fetch(state.store);
 
     state.mkAttrs(v, 8);
-    auto storePath = state.store->printStorePath(tree.storePath);
+    auto storePath = state.store->printStorePath(
+        state.store->makeFixedOutputPathFromCA(tree.storePath));
     mkString(*state.allocAttr(v, state.sOutPath), storePath, PathSet({storePath}));
     // Backward compatibility: set 'rev' to
     // 0000000000000000000000000000000000000000 for a dirty tree.

src/libexpr/primops/fetchMercurial.cc

@@ -31,7 +31,7 @@ static void prim_fetchMercurial(EvalState & state, const Pos & pos, Value * * ar
                 // be both a revision or a branch/tag name.
                 auto value = state.forceStringNoCtx(*attr.value, *attr.pos);
                 if (std::regex_match(value, revRegex))
-                    rev = Hash(value, htSHA1);
+                    rev = Hash::parseAny(value, htSHA1);
                 else
                     ref = value;
             }
@@ -71,7 +71,8 @@ static void prim_fetchMercurial(EvalState & state, const Pos & pos, Value * * ar
     auto [tree, input2] = input.fetch(state.store);
 
     state.mkAttrs(v, 8);
-    auto storePath = state.store->printStorePath(tree.storePath);
+    auto storePath = state.store->printStorePath(
+        state.store->makeFixedOutputPathFromCA(tree.storePath));
     mkString(*state.allocAttr(v, state.sOutPath), storePath, PathSet({storePath}));
     if (input2.getRef())
         mkString(*state.allocAttr(v, state.symbols.create("branch")), *input2.getRef());

src/libexpr/primops/fetchTree.cc

@@ -20,7 +20,8 @@ void emitTreeAttrs(
 
     state.mkAttrs(v, 8);
 
-    auto storePath = state.store->printStorePath(tree.storePath);
+    auto storePath = state.store->printStorePath(
+        state.store->makeFixedOutputPathFromCA(tree.storePath));
 
     mkString(*state.allocAttr(v, state.sOutPath), storePath, PathSet({storePath}));
 
@@ -146,20 +147,34 @@ static void fetch(EvalState & state, const Pos & pos, Value * * args, Value & v,
     if (evalSettings.pureEval && !expectedHash)
         throw Error("in pure evaluation mode, '%s' requires a 'sha256' argument", who);
 
+    // try to substitute if we can
+    if (settings.useSubstitutes && expectedHash) {
+        auto substitutableStorePath = fetchers::trySubstitute(state.store,
+            unpack ? FileIngestionMethod::Recursive : FileIngestionMethod::Flat, *expectedHash, name);
+        if (substitutableStorePath) {
+            auto substitutablePath = state.store->toRealPath(*substitutableStorePath);
+            if (state.allowedPaths)
+                state.allowedPaths->insert(substitutablePath);
+
+            mkString(v, substitutablePath, PathSet({substitutablePath}));
+            return;
+        }
+    }
+
     auto storePath =
         unpack
         ? fetchers::downloadTarball(state.store, *url, name, (bool) expectedHash).first.storePath
         : fetchers::downloadFile(state.store, *url, name, (bool) expectedHash).storePath;
 
-    auto path = state.store->toRealPath(storePath);
+    auto path = state.store->toRealPath(state.store->makeFixedOutputPathFromCA(storePath));
 
     if (expectedHash) {
         auto hash = unpack
             ? state.store->queryPathInfo(storePath)->narHash
             : hashFile(htSHA256, path);
         if (hash != *expectedHash)
             throw Error((unsigned int) 102, "hash mismatch in file downloaded from '%s':\n  wanted: %s\n  got:    %s",
-                *url, expectedHash->to_string(Base32, true), hash.to_string(Base32, true));
+                *url, expectedHash->to_string(Base32, true), hash->to_string(Base32, true));
     }
 
     if (state.allowedPaths)

src/libexpr/value-to-xml.hh

@@ -10,5 +10,5 @@ namespace nix {
 
 void printValueAsXML(EvalState & state, bool strict, bool location,
     Value & v, std::ostream & out, PathSet & context);
- 
+
 }

src/libfetchers/cache.cc

@@ -51,18 +51,19 @@ struct CacheImpl : Cache
         ref<Store> store,
         const Attrs & inAttrs,
         const Attrs & infoAttrs,
-        const StorePath & storePath,
+        const StorePathDescriptor & storePathDesc,
         bool immutable) override
     {
         _state.lock()->add.use()
             (attrsToJson(inAttrs).dump())
             (attrsToJson(infoAttrs).dump())
-            (store->printStorePath(storePath))
+            // FIXME should use JSON for store path descriptor
+            (renderStorePathDescriptor(storePathDesc))
             (immutable)
             (time(0)).exec();
     }
 
-    std::optional<std::pair<Attrs, StorePath>> lookup(
+    std::optional<std::pair<Attrs, StorePathDescriptor>> lookup(
         ref<Store> store,
         const Attrs & inAttrs) override
     {
@@ -90,9 +91,10 @@ struct CacheImpl : Cache
         }
 
         auto infoJson = stmt.getStr(0);
-        auto storePath = store->parseStorePath(stmt.getStr(1));
+        auto storePathDesc = parseStorePathDescriptor(stmt.getStr(1));
         auto immutable = stmt.getInt(2) != 0;
         auto timestamp = stmt.getInt(3);
+        auto storePath = store->makeFixedOutputPathFromCA(storePathDesc);
 
         store->addTempRoot(storePath);
         if (!store->isValidPath(storePath)) {
@@ -107,7 +109,7 @@ struct CacheImpl : Cache
         return Result {
             .expired = !immutable && (settings.tarballTtl.get() == 0 || timestamp + settings.tarballTtl < time(0)),
             .infoAttrs = jsonToAttrs(nlohmann::json::parse(infoJson)),
-            .storePath = std::move(storePath)
+            .storePath = std::move(storePathDesc)
         };
     }
 };