diff --git a/src/libexpr/primops/fetchTree.cc b/src/libexpr/primops/fetchTree.cc
index f040a35109a8..93656ca043e1 100644
--- a/src/libexpr/primops/fetchTree.cc
+++ b/src/libexpr/primops/fetchTree.cc
@@ -30,9 +30,13 @@ void emitTreeAttrs(
 
     // FIXME: support arbitrary input attributes.
 
-    auto narHash = input.getNarHash();
-    assert(narHash);
-    attrs.alloc("narHash").mkString(narHash->to_string(SRI, true));
+    if (auto narHash = input.getNarHash()) {
+        attrs.alloc("narHash").mkString(narHash->to_string(SRI, true));
+    } else if (auto treeHash = input.getTreeHash()) {
+        attrs.alloc("treeHash").mkString(treeHash->to_string(SRI, true));
+    } else
+        /* Must have either tree hash or NAR hash */
+        assert(false);
 
     if (input.getType() == "git")
         attrs.alloc("submodules").mkBool(
@@ -50,6 +54,11 @@ void emitTreeAttrs(
             attrs.alloc("shortRev").mkString(emptyHash.gitShortRev());
         }
 
+        if (auto treeHash = input.getTreeHash()) {
+            attrs.alloc("treeHash").mkString(treeHash->gitRev());
+            attrs.alloc("shortTreeHash").mkString(treeHash->gitRev());
+        }
+
         if (auto revCount = input.getRevCount())
             attrs.alloc("revCount").mkInt(*revCount);
         else if (emptyRevFallback)
diff --git a/src/libfetchers/fetchers.cc b/src/libfetchers/fetchers.cc
index e683b9f804a6..a3963640d839 100644
--- a/src/libfetchers/fetchers.cc
+++ b/src/libfetchers/fetchers.cc
@@ -25,6 +25,8 @@ static void fixupInput(Input & input)
     input.getRef();
     if (input.getRev())
         input.locked = true;
+    if (input.getTreeHash())
+        input.locked = true;
     input.getRevCount();
     input.getLastModified();
     if (input.getNarHash())
@@ -89,7 +91,7 @@ Attrs Input::toAttrs() const
 
 bool Input::hasAllInfo() const
 {
-    return getNarHash() && scheme && scheme->hasAllInfo(*this);
+    return scheme && scheme->hasAllInfo(*this);
 }
 
 bool Input::operator ==(const Input & other) const
@@ -213,14 +215,19 @@ std::string Input::getName() const
 
 StorePath Input::computeStorePath(Store & store) const
 {
-    auto narHash = getNarHash();
-    if (!narHash)
-        throw Error("cannot compute store path for unlocked input '%s'", to_string());
-    return store.makeFixedOutputPath(getName(), FixedOutputInfo {
-        .method = FileIngestionMethod::Recursive,
-        .hash = *narHash,
-        .references = {},
-    });
+    if (auto treeHash = getTreeHash())
+        return store.makeFixedOutputPath(getName(), FixedOutputInfo {
+            .method = FileIngestionMethod::Git,
+            .hash = *treeHash,
+            .references = {},
+        });
+    if (auto narHash = getNarHash())
+        return store.makeFixedOutputPath(getName(), FixedOutputInfo {
+            .method = FileIngestionMethod::Recursive,
+            .hash = *narHash,
+            .references = {},
+        });
+    throw Error("cannot compute store path for unlocked input '%s'", to_string());
 }
 
 std::string Input::getType() const
@@ -262,6 +269,15 @@ std::optional<Hash> Input::getRev() const
     return hash;
 }
 
+std::optional<Hash> Input::getTreeHash() const
+{
+    if (auto s = maybeGetStrAttr(attrs, "treeHash")) {
+        experimentalFeatureSettings.require(Xp::GitHashing);
+        return Hash::parseAny(*s, htSHA1);
+    }
+    return {};
+}
+
 std::optional<uint64_t> Input::getRevCount() const
 {
     if (auto n = maybeGetIntAttr(attrs, "revCount"))
diff --git a/src/libfetchers/fetchers.hh b/src/libfetchers/fetchers.hh
index 6e10e95134fd..e7af5f9a8d17 100644
--- a/src/libfetchers/fetchers.hh
+++ b/src/libfetchers/fetchers.hh
@@ -110,6 +110,7 @@ public:
     std::optional<Hash> getNarHash() const;
     std::optional<std::string> getRef() const;
     std::optional<Hash> getRev() const;
+    std::optional<Hash> getTreeHash() const;
     std::optional<uint64_t> getRevCount() const;
     std::optional<time_t> getLastModified() const;
 };
diff --git a/src/libfetchers/git.cc b/src/libfetchers/git.cc
index f8d89ab2fcdd..5036bf511e71 100644
--- a/src/libfetchers/git.cc
+++ b/src/libfetchers/git.cc
@@ -3,6 +3,7 @@
 #include "globals.hh"
 #include "tarfile.hh"
 #include "store-api.hh"
+#include "git.hh"
 #include "url-parts.hh"
 #include "pathlocks.hh"
 #include "util.hh"
@@ -200,7 +201,7 @@ WorkdirInfo getWorkdirInfo(const Input & input, const Path & workdir)
     return WorkdirInfo { .clean = clean, .hasHead = hasHead };
 }
 
-std::pair<StorePath, Input> fetchFromWorkdir(ref<Store> store, Input & input, const Path & workdir, const WorkdirInfo & workdirInfo)
+std::pair<StorePath, Input> fetchFromWorkdir(ref<Store> store, Input & input, const Path & workdir, const WorkdirInfo & workdirInfo, FileIngestionMethod ingestionMethod)
 {
     const bool submodules = maybeGetBoolAttr(input.attrs, "submodules").value_or(false);
     auto gitDir = ".git";
@@ -272,7 +273,7 @@ struct GitInputScheme : InputScheme
         attrs.emplace("type", "git");
 
         for (auto & [name, value] : url.query) {
-            if (name == "rev" || name == "ref")
+            if (name == "rev" || name == "ref" || name == "treeHash" || name == "gitIngestion")
                 attrs.emplace(name, value);
             else if (name == "shallow" || name == "submodules" || name == "allRefs")
                 attrs.emplace(name, Explicit<bool> { value == "1" });
@@ -290,7 +291,7 @@ struct GitInputScheme : InputScheme
         if (maybeGetStrAttr(attrs, "type") != "git") return {};
 
         for (auto & [name, value] : attrs)
-            if (name != "type" && name != "url" && name != "ref" && name != "rev" && name != "shallow" && name != "submodules" && name != "lastModified" && name != "revCount" && name != "narHash" && name != "allRefs" && name != "name" && name != "dirtyRev" && name != "dirtyShortRev")
+            if (name != "type" && name != "url" && name != "ref" && name != "rev" && name != "shallow" && name != "submodules" && name != "gitIngestion" && name != "treeHash"  && name != "lastModified" && name != "revCount" && name != "narHash" && name != "allRefs" && name != "name" && name != "dirtyRev" && name != "dirtyShortRev")
                 throw Error("unsupported Git input attribute '%s'", name);
 
         parseURL(getStrAttr(attrs, "url"));
@@ -313,6 +314,9 @@ struct GitInputScheme : InputScheme
         auto url = parseURL(getStrAttr(input.attrs, "url"));
         if (url.scheme != "git") url.scheme = "git+" + url.scheme;
         if (auto rev = input.getRev()) url.query.insert_or_assign("rev", rev->gitRev());
+        if (auto treeHash = input.getTreeHash()) url.query.insert_or_assign("treeHash", treeHash->gitRev());
+        if (maybeGetBoolAttr(input.attrs, "gitIngestion").value_or((bool) input.getTreeHash()))
+            url.query.insert_or_assign("gitIngestion", "1");
         if (auto ref = input.getRef()) url.query.insert_or_assign("ref", *ref);
         if (maybeGetBoolAttr(input.attrs, "shallow").value_or(false))
             url.query.insert_or_assign("shallow", "1");
@@ -323,11 +327,18 @@ struct GitInputScheme : InputScheme
     {
         bool maybeDirty = !input.getRef();
         bool shallow = maybeGetBoolAttr(input.attrs, "shallow").value_or(false);
-        return
+        bool submodules = maybeGetBoolAttr(input.attrs, "submodules").value_or(false);
+        /* FIXME just requiring tree hash is necessary for substitutions to
+           work for now, but breaks eval purity. Need a better solution before
+           upstreaming. */
+        return (input.getTreeHash() && !submodules) || (
             maybeGetIntAttr(input.attrs, "lastModified")
-            && (shallow || maybeDirty || maybeGetIntAttr(input.attrs, "revCount"));
+            && (shallow || maybeDirty || maybeGetIntAttr(input.attrs, "revCount"))
+            && input.getNarHash());
     }
 
+    /* FIXME no overriding the tree hash / flake registry support for tree
+       hashes, for now. */
     Input applyOverrides(
         const Input & input,
         std::optional<std::string> ref,
@@ -364,7 +375,7 @@ struct GitInputScheme : InputScheme
     std::optional<Path> getSourcePath(const Input & input) override
     {
         auto url = parseURL(getStrAttr(input.attrs, "url"));
-        if (url.scheme == "file" && !input.getRef() && !input.getRev())
+        if (url.scheme == "file" && !input.getRef() && !input.getRev() && !input.getTreeHash())
             return url.path;
         return {};
     }
@@ -412,6 +423,11 @@ struct GitInputScheme : InputScheme
         if (submodules) cacheType += "-submodules";
         if (allRefs) cacheType += "-all-refs";
 
+        auto ingestionMethod =
+            maybeGetBoolAttr(input.attrs, "gitIngestion").value_or((bool) input.getTreeHash())
+            ? FileIngestionMethod::Git
+            : FileIngestionMethod::Recursive;
+
         auto checkHashType = [&](const std::optional<Hash> & hash)
         {
             if (hash.has_value() && !(hash->type == htSHA1 || hash->type == htSHA256))
@@ -420,20 +436,32 @@ struct GitInputScheme : InputScheme
 
         auto getLockedAttrs = [&]()
         {
-            checkHashType(input.getRev());
-
-            return Attrs({
+            Attrs attrs({
                 {"type", cacheType},
                 {"name", name},
-                {"rev", input.getRev()->gitRev()},
             });
+            if (auto optH = input.getTreeHash()) {
+                auto h = *std::move(optH);
+                checkHashType(h);
+                attrs.insert_or_assign("treeHash", h.gitRev());
+            }
+            if (auto optH = input.getRev()) {
+                auto h = *std::move(optH);
+                checkHashType(h);
+                attrs.insert_or_assign("rev", h.gitRev());
+            }
+            if (maybeGetBoolAttr(input.attrs, "gitIngestion").value_or((bool) input.getTreeHash()))
+                attrs.insert_or_assign("gitIngestion", true);
+            return attrs;
         };
 
         auto makeResult = [&](const Attrs & infoAttrs, StorePath && storePath)
             -> std::pair<StorePath, Input>
         {
-            assert(input.getRev());
+            assert(input.getRev() || input.getTreeHash());
+            /* If was originally set, that original value must be preserved. */
             assert(!_input.getRev() || _input.getRev() == input.getRev());
+            assert(!_input.getTreeHash() || _input.getTreeHash() == input.getTreeHash());
             if (!shallow)
                 input.attrs.insert_or_assign("revCount", getIntAttr(infoAttrs, "revCount"));
             input.attrs.insert_or_assign("lastModified", getIntAttr(infoAttrs, "lastModified"));
@@ -450,10 +478,10 @@ struct GitInputScheme : InputScheme
 
         /* If this is a local directory and no ref or revision is given,
            allow fetching directly from a dirty workdir. */
-        if (!input.getRef() && !input.getRev() && isLocal) {
+        if (!input.getRef() && !input.getRev() && !input.getTreeHash() && isLocal) {
             auto workdirInfo = getWorkdirInfo(input, actualUrl);
             if (!workdirInfo.clean) {
-                return fetchFromWorkdir(store, input, actualUrl, workdirInfo);
+                return fetchFromWorkdir(store, input, actualUrl, workdirInfo, ingestionMethod);
             }
         }
 
@@ -462,6 +490,8 @@ struct GitInputScheme : InputScheme
             {"name", name},
             {"url", actualUrl},
         });
+        if (ingestionMethod == FileIngestionMethod::Git)
+            unlockedAttrs.insert_or_assign("gitIngestion", true);
 
         Path repoDir;
 
@@ -476,9 +506,14 @@ struct GitInputScheme : InputScheme
                 unlockedAttrs.insert_or_assign("ref", *head);
             }
 
-            if (!input.getRev())
-                input.attrs.insert_or_assign("rev",
-                    Hash::parseAny(chomp(runProgram("git", true, { "-C", actualUrl, "--git-dir", gitDir, "rev-parse", *input.getRef() })), htSHA1).gitRev());
+            if (!input.getRev() && !input.getTreeHash()) {
+                auto getHash = [&](std::string rev) {
+                    return Hash::parseAny(chomp(runProgram("git", true, { "-C", actualUrl, "--git-dir", gitDir, "rev-parse", rev })), htSHA1).gitRev();
+                };
+                input.attrs.insert_or_assign("rev", getHash(*input.getRef()));
+                if (experimentalFeatureSettings.isEnabled(Xp::GitHashing))
+                    input.attrs.insert_or_assign("treeHash", getHash(*input.getRef() + ":"));
+            }
 
             repoDir = actualUrl;
         } else {
@@ -498,11 +533,33 @@ struct GitInputScheme : InputScheme
             }
 
             if (auto res = getCache()->lookup(store, unlockedAttrs)) {
-                auto rev2 = Hash::parseAny(getStrAttr(res->first, "rev"), htSHA1);
-                if (!input.getRev() || input.getRev() == rev2) {
-                    input.attrs.insert_or_assign("rev", rev2.gitRev());
-                    return makeResult(res->first, std::move(res->second));
+                bool found = false;
+
+                if (std::optional revS = maybeGetStrAttr(res->first, "rev")) {
+                    auto rev2 = Hash::parseAny(*revS, htSHA1);
+                    if (!input.getRev() || input.getRev() == rev2) {
+                        input.attrs.insert_or_assign("rev", rev2.gitRev());
+                        found = true;
+                    }
                 }
+
+                if (experimentalFeatureSettings.isEnabled(Xp::GitHashing)) {
+                    if (std::optional treeHashS = maybeGetStrAttr(res->first, "treeHash")) {
+                        auto treeHash2 = Hash::parseNonSRIUnprefixed(*treeHashS, htSHA1);
+                        if (!input.getTreeHash() || input.getTreeHash() == treeHash2) {
+                            input.attrs.insert_or_assign("treeHash", treeHash2.gitRev());
+                            found = true;
+                        }
+                    }
+                }
+
+                bool correctIngestion =
+                    maybeGetBoolAttr(input.attrs, "gitIngestion").value_or(false)
+                    ? ingestionMethod == FileIngestionMethod::Git
+                    : ingestionMethod == FileIngestionMethod::Recursive;
+
+                if (correctIngestion && found)
+                    return makeResult(res->first, std::move(res->second));
             }
 
             Path cacheDir = getCachePath(actualUrl);
@@ -524,11 +581,12 @@ struct GitInputScheme : InputScheme
             bool doFetch;
             time_t now = time(0);
 
-            /* If a rev was specified, we need to fetch if it's not in the
-               repo. */
-            if (input.getRev()) {
+            /* If a rev or treeHash is specified, we need to fetch if
+               it's not in the repo. */
+            if (input.getRev() || input.getTreeHash()) {
                 try {
-                    runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "cat-file", "-e", input.getRev()->gitRev() });
+                    auto fetchHash = input.getTreeHash() ? input.getTreeHash() : input.getRev();
+                    runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "cat-file", "-e", fetchHash->gitRev() });
                     doFetch = false;
                 } catch (ExecError & e) {
                     if (WIFEXITED(e.status)) {
@@ -575,12 +633,23 @@ struct GitInputScheme : InputScheme
                     warn("could not update cached head '%s' for '%s'", *input.getRef(), actualUrl);
             }
 
-            if (!input.getRev())
-                input.attrs.insert_or_assign("rev", Hash::parseAny(chomp(readFile(localRefFile)), htSHA1).gitRev());
+            if (!input.getRev() && !input.getTreeHash()) {
+                auto rev = Hash::parseAny(chomp(readFile(localRefFile)), htSHA1).gitRev();
+                input.attrs.insert_or_assign("rev", rev);
+                if (experimentalFeatureSettings.isEnabled(Xp::GitHashing))
+                    input.attrs.insert_or_assign("treeHash",
+                        Hash::parseAny(chomp(runProgram("git", true, { "-C", repoDir, "rev-parse", rev + ":" })), htSHA1).gitRev());
+            }
 
             // cache dir lock is removed at scope end; we will only use read-only operations on specific revisions in the remainder
         }
 
+        if (input.getTreeHash()) {
+            auto type = chomp(runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "cat-file", "-t", input.getTreeHash()->gitRev() }));
+            if (type != "tree")
+                throw Error("Need a tree object, found '%s' object in %s", type, input.getTreeHash()->gitRev());
+        }
+
         bool isShallow = chomp(runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "rev-parse", "--is-shallow-repository" })) == "true";
 
         if (isShallow && !shallow)
@@ -588,7 +657,10 @@ struct GitInputScheme : InputScheme
 
         // FIXME: check whether rev is an ancestor of ref.
 
-        printTalkative("using revision %s of repo '%s'", input.getRev()->gitRev(), actualUrl);
+        if (auto rev = input.getRev())
+            printTalkative("using revision %s of repo '%s'", rev->gitRev(), actualUrl);
+        if (auto treeHash = input.getTreeHash())
+            printTalkative("using tree %s of repo '%s'", treeHash->gitRev(), actualUrl);
 
         /* Now that we know the ref, check again whether we have it in
            the store. */
@@ -599,10 +671,20 @@ struct GitInputScheme : InputScheme
         AutoDelete delTmpDir(tmpDir, true);
         PathFilter filter = defaultPathFilter;
 
+        auto [fetchHash, fetchHashType] = input.getTreeHash()
+            ? (std::pair { input.getTreeHash().value(), true })
+            : (std::pair { input.getRev().value(), false });
+
         auto result = runProgram(RunOptions {
             .program = "git",
-            .args = { "-C", repoDir, "--git-dir", gitDir, "cat-file", "commit", input.getRev()->gitRev() },
-            .mergeStderrToStdout = true
+            .args = {
+                "-C", repoDir,
+                "--git-dir", gitDir,
+                "cat-file",
+                fetchHashType ? "tree" : "commit",
+                fetchHash.gitRev(),
+            },
+            .mergeStderrToStdout = true,
         });
         if (WEXITSTATUS(result.first) == 128
             && result.second.find("bad file") != std::string::npos)
@@ -612,13 +694,18 @@ struct GitInputScheme : InputScheme
                 "Please make sure that the " ANSI_BOLD "rev" ANSI_NORMAL " exists on the "
                 ANSI_BOLD "ref" ANSI_NORMAL " you've specified or add " ANSI_BOLD
                 "allRefs = true;" ANSI_NORMAL " to " ANSI_BOLD "fetchGit" ANSI_NORMAL ".",
-                input.getRev()->gitRev(),
+                fetchHash.gitRev(),
                 *input.getRef(),
                 actualUrl
             );
         }
 
         if (submodules) {
+            if (input.getTreeHash())
+                throw Error("Cannot fetch specific tree hashes if there are submodules");
+            if (ingestionMethod == FileIngestionMethod::Git)
+                warn("Nix's computed git tree hash will be different when submodules are converted to regular directories");
+
             Path tmpGitDir = createTempDir();
             AutoDelete delTmpGitDir(tmpGitDir, true);
 
@@ -633,7 +720,7 @@ struct GitInputScheme : InputScheme
                         "--update-head-ok", "--", repoDir, "refs/*:refs/*" }, {}, true);
             }
 
-            runProgram("git", true, { "-C", tmpDir, "checkout", "--quiet", input.getRev()->gitRev() });
+            runProgram("git", true, { "-C", tmpDir, "checkout", "--quiet", input.getTreeHash() ? input.getTreeHash()->gitRev() : input.getRev()->gitRev() });
 
             /* Ensure that we use the correct origin for fetching
                submodules. This matters for submodules with relative
@@ -662,12 +749,13 @@ struct GitInputScheme : InputScheme
 
             filter = isNotDotGitDirectory;
         } else {
+            auto & fetchHash_ = fetchHash; // Work-around clang restriction.
             // FIXME: should pipe this, or find some better way to extract a
             // revision.
             auto source = sinkToSource([&](Sink & sink) {
                 runProgram2({
                     .program = "git",
-                    .args = { "-C", repoDir, "--git-dir", gitDir, "archive", input.getRev()->gitRev() },
+                    .args = { "-C", repoDir, "--git-dir", gitDir, "archive", fetchHash_.gitRev() },
                     .standardOut = &sink
                 });
             });
@@ -675,20 +763,39 @@ struct GitInputScheme : InputScheme
             unpackTarfile(*source, tmpDir);
         }
 
-        auto storePath = store->addToStore(name, tmpDir, FileIngestionMethod::Recursive, htSHA256, filter);
+        auto storePath = store->addToStore(name, tmpDir, ingestionMethod, ingestionMethod == FileIngestionMethod::Git ? htSHA1 : htSHA256, filter);
 
-        auto lastModified = std::stoull(runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "log", "-1", "--format=%ct", "--no-show-signature", input.getRev()->gitRev() }));
+        // verify treeHash is what we actually obtained in the nix store
+        if (auto treeHash = input.getTreeHash()) {
+            auto path = store->toRealPath(store->printStorePath(storePath));
+            auto gotHash = dumpGitHash(htSHA1, path);
+            if (gotHash != input.getTreeHash())
+                throw Error("Git hash mismatch in input '%s' (%s), expected '%s', got '%s'",
+                    input.to_string(), path, treeHash->gitRev(), gotHash.gitRev());
+        }
 
-        Attrs infoAttrs({
-            {"rev", input.getRev()->gitRev()},
-            {"lastModified", lastModified},
-        });
+        Attrs infoAttrs({});
+
+        if (auto rev = input.getRev()) {
+            infoAttrs.insert_or_assign("rev", rev->gitRev());
+            auto lastModified = std::stoull(runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "log", "-1", "--format=%ct", "--no-show-signature", rev->gitRev() }));
+            infoAttrs.insert_or_assign("lastModified", lastModified);
+        } else
+            infoAttrs.insert_or_assign("lastModified", (uint64_t) 0);
 
-        if (!shallow)
-            infoAttrs.insert_or_assign("revCount",
-                std::stoull(runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "rev-list", "--count", input.getRev()->gitRev() })));
+        if (experimentalFeatureSettings.isEnabled(Xp::GitHashing))
+            if (auto treeHash = input.getTreeHash())
+                infoAttrs.insert_or_assign("treeHash", treeHash->gitRev());
+
+        if (!shallow) {
+            if (auto rev = input.getRev())
+                infoAttrs.insert_or_assign("revCount",
+                    std::stoull(runProgram("git", true, { "-C", repoDir, "--git-dir", gitDir, "rev-list", "--count", rev->gitRev() })));
+            else
+                infoAttrs.insert_or_assign("revCount", (uint64_t) 0);
+        }
 
-        if (!_input.getRev())
+        if (!_input.getRev() && !_input.getTreeHash())
             getCache()->add(
                 store,
                 unlockedAttrs,
diff --git a/src/libfetchers/github.cc b/src/libfetchers/github.cc
index 291f457f0d35..4fa4f3e07b29 100644
--- a/src/libfetchers/github.cc
+++ b/src/libfetchers/github.cc
@@ -134,7 +134,7 @@ struct GitArchiveInputScheme : InputScheme
 
     bool hasAllInfo(const Input & input) const override
     {
-        return input.getRev() && maybeGetIntAttr(input.attrs, "lastModified");
+        return input.getNarHash() && input.getRev() && maybeGetIntAttr(input.attrs, "lastModified");
     }
 
     Input applyOverrides(
diff --git a/src/libfetchers/mercurial.cc b/src/libfetchers/mercurial.cc
index 51fd1ed428b0..74cb9c36380a 100644
--- a/src/libfetchers/mercurial.cc
+++ b/src/libfetchers/mercurial.cc
@@ -102,7 +102,8 @@ struct MercurialInputScheme : InputScheme
     {
         // FIXME: ugly, need to distinguish between dirty and clean
         // default trees.
-        return input.getRef() == "default" || maybeGetIntAttr(input.attrs, "revCount");
+        return input.getNarHash()
+            && (input.getRef() == "default" || maybeGetIntAttr(input.attrs, "revCount"));
     }
 
     Input applyOverrides(
diff --git a/src/libfetchers/path.cc b/src/libfetchers/path.cc
index 01f1be97822c..10670bb4ac5e 100644
--- a/src/libfetchers/path.cc
+++ b/src/libfetchers/path.cc
@@ -68,7 +68,7 @@ struct PathInputScheme : InputScheme
 
     bool hasAllInfo(const Input & input) const override
     {
-        return true;
+        return (bool) input.getNarHash();
     }
 
     std::optional<Path> getSourcePath(const Input & input) override
diff --git a/tests/git-hashing/fetching.sh b/tests/git-hashing/fetching.sh
new file mode 100644
index 000000000000..06ffcb35296e
--- /dev/null
+++ b/tests/git-hashing/fetching.sh
@@ -0,0 +1,41 @@
+source common.sh
+
+[[ -n $(type -p git) ]] || skipTest "no git"
+
+repo=$TEST_ROOT/git
+
+rm -rf $repo $TEST_HOME/.cache/nix
+
+git init $repo
+git -C $repo config user.email "foobar@example.com"
+git -C $repo config user.name "Foobar"
+
+echo utrecht > $repo/hello
+touch $repo/.gitignore
+git -C $repo add hello .gitignore
+git -C $repo commit -m 'Bla1'
+
+echo world > $repo/hello
+git -C $repo commit -m 'Bla2' -a
+
+treeHash=$(git -C $repo rev-parse HEAD:)
+
+# Fetch the default branch.
+path=$(nix eval --raw --expr "(builtins.fetchTree { type = \"git\"; url = file://$repo; treeHash = \"$treeHash\"; }).outPath")
+[[ $(cat $path/hello) = world ]]
+
+# Submodules cause error.
+(! nix eval --raw --expr "(builtins.fetchTree { type = \"git\"; url = file://$repo; treeHash = \"$treeHash\"; submodules = true; }).outPath")
+
+# Check that we can substitute it from other places.
+nix copy --to file://$cacheDir $path
+nix-store --delete $path
+path2=$(nix eval --raw --expr "(builtins.fetchTree { type = \"git\"; url = file:///no-such-repo; treeHash = \"$treeHash\"; }).outPath" --substituters file://$cacheDir --option substitute true)
+[ $path2 = $path ]
+
+# HEAD should be the same path and tree hash as tree
+nix eval --impure --expr "(builtins.fetchTree { type = \"git\"; url = file://$repo; ref = \"HEAD\"; gitIngestion = true; })"
+treeHash2=$(nix eval --impure --raw --expr "(builtins.fetchTree { type = \"git\"; url = file://$repo; ref = \"HEAD\"; gitIngestion = true; }).treeHash")
+[ $treeHash = $treeHash2 ]
+path3=$(nix eval --impure --raw --expr "(builtins.fetchTree { type = \"git\"; url = file://$repo; ref = \"HEAD\"; gitIngestion = true; }).outPath")
+[ $path3 = $path ]
diff --git a/tests/git-hashing/local.mk b/tests/git-hashing/local.mk
index ebec019402b9..8e8218ccec8b 100644
--- a/tests/git-hashing/local.mk
+++ b/tests/git-hashing/local.mk
@@ -1,5 +1,6 @@
 git-hashing-tests := \
-  $(d)/simple.sh
+  $(d)/simple.sh \
+  $(d)/fetching.sh
 
 install-tests-groups += git-hashing