fix(tectonix): handle dirty zones in full checkouts

burke · burke · commit c6aa9732a1ef · 2026-05-30T11:06:19.000-04:00
Expose full-checkout detection based on core.sparseCheckout so companion Tectonix code can distinguish sparse checkouts from regular source checkouts. In full checkouts, map dirty git-status paths back to their containing zones and only materialize dirty entries instead of expanding a manifest-sized clean map.

Keep sparse checkout behavior compatible by initializing sparse roots as clean and add a per-zone dirty builtin for source-available mode.
diff --git a/src/libexpr/eval.cc b/src/libexpr/eval.cc
@@ -485,6 +485,44 @@ bool EvalState::isTectonixSourceAvailable() const
     return !settings.tectonixCheckoutPath.get().empty();
 }
 
+bool EvalState::isTectonixFullCheckout() const
+{
+    std::call_once(tectonixFullCheckoutFlag, [this]() {
+        tectonixFullCheckout = false;
+        if (!isTectonixSourceAvailable())
+            return;
+
+        StringMap gitEnvironment = getEnv();
+        gitEnvironment.erase("GIT_DIR");
+        gitEnvironment.erase("GIT_WORK_TREE");
+        gitEnvironment.erase("GIT_COMMON_DIR");
+
+        auto checkoutPath = settings.tectonixCheckoutPath.get();
+        auto [gitConfigCode, gitConfigOutput] = runProgram(
+            {.program = "git",
+             .args = {"-C", checkoutPath, "config", "--bool", "--get", "core.sparseCheckout"},
+             .environment = gitEnvironment});
+
+        // If core.sparseCheckout is unset, git config exits non-zero. That is a
+        // normal full-checkout state. Other failures will be caught later by the
+        // git-status path and treated as clean.
+        if (!statusOk(gitConfigCode)) {
+            tectonixFullCheckout = true;
+            debug("source checkout at '%s' has no sparse-checkout config; treating as full checkout", checkoutPath);
+            return;
+        }
+
+        auto value = trim(gitConfigOutput);
+        tectonixFullCheckout = value != "true";
+        debug(
+            "source checkout at '%s' core.sparseCheckout=%s; fullCheckout=%s",
+            checkoutPath,
+            value,
+            tectonixFullCheckout ? "true" : "false");
+    });
+    return tectonixFullCheckout;
+}
+
 // Helper to normalize zone paths: strip leading // prefix
 // Zone paths in manifest have // prefix (e.g., //areas/tools/dev)
 // Filesystem operations need paths without // (e.g., areas/tools/dev)
@@ -496,6 +534,22 @@ static std::string normalizeZonePath(std::string_view zonePath)
     return path;
 }
 
+static std::optional<std::string> findZonePathForRepoPath(const nlohmann::json & manifest, std::string_view repoPath)
+{
+    std::string candidate(repoPath);
+    while (!candidate.empty()) {
+        auto zonePath = "//" + candidate;
+        if (manifest.contains(zonePath))
+            return zonePath;
+
+        auto slash = candidate.rfind('/');
+        if (slash == std::string::npos)
+            break;
+        candidate.resize(slash);
+    }
+    return std::nullopt;
+}
+
 // Helper to sanitize zone path for use in store path names.
 // Store paths only allow: a-zA-Z0-9 and +-._?=
 // Replaces / with - and any other invalid chars with _
@@ -627,10 +681,18 @@ const std::map<std::string, EvalState::ZoneDirtyInfo> & EvalState::getTectonixDi
         if (!isTectonixSourceAvailable())
             return;
 
-        // Get sparse checkout roots (zone IDs)
-        auto & sparseRoots = getTectonixSparseCheckoutRoots();
-        if (sparseRoots.empty())
-            return;
+        bool fullCheckout = isTectonixFullCheckout();
+
+        // In sparse checkout mode, use the explicit root set. In full checkout
+        // mode, avoid expanding every zone eagerly; dirty files will be mapped
+        // to zones directly from their repo-relative paths.
+        const std::set<std::string> * sparseRoots = nullptr;
+        if (!fullCheckout) {
+            auto & roots = getTectonixSparseCheckoutRoots();
+            if (roots.empty())
+                return;
+            sparseRoots = &roots;
+        }
 
         // Get manifest (uses cached parsed JSON)
         const nlohmann::json * manifest;
@@ -644,21 +706,26 @@ const std::map<std::string, EvalState::ZoneDirtyInfo> & EvalState::getTectonixDi
             return;
         }
 
-        // Build map of zone ID -> zone path for sparse roots only
+        // Build map of zone ID -> zone path for sparse roots only. Full
+        // checkouts do not need this map because every zone is physically
+        // available and clean zones can stay implicit.
         std::map<std::string, std::string> zoneIdToPath;
-        for (auto & [path, value] : manifest->items()) {
-            if (!value.contains("id") || !value.at("id").is_string()) {
-                warn("zone '%s' in manifest has missing or non-string 'id' field", path);
-                continue;
+        if (!fullCheckout) {
+            for (auto & [path, value] : manifest->items()) {
+                if (!value.contains("id") || !value.at("id").is_string()) {
+                    warn("zone '%s' in manifest has missing or non-string 'id' field", path);
+                    continue;
+                }
+                auto & id = value.at("id").get_ref<const std::string &>();
+                if (sparseRoots->count(id))
+                    zoneIdToPath[id] = path;
             }
-            auto & id = value.at("id").get_ref<const std::string &>();
-            if (sparseRoots.count(id))
-                zoneIdToPath[id] = path;
-        }
 
-        // Initialize all sparse-checked-out zones as not dirty
-        for (auto & [zoneId, zonePath] : zoneIdToPath) {
-            tectonixDirtyZones[zonePath] = {};
+            // Initialize all sparse-checked-out zones as not dirty. Full
+            // checkouts only materialize dirty entries.
+            for (auto & [zoneId, zonePath] : zoneIdToPath) {
+                tectonixDirtyZones[zonePath] = {};
+            }
         }
 
         // Get dirty files via git status with -z for NUL-separated output
@@ -710,11 +777,22 @@ const std::map<std::string, EvalState::ZoneDirtyInfo> & EvalState::getTectonixDi
             }
 
             for (const auto & filePath : pathsToCheck) {
+                auto repoPath = filePath.substr(1);
+
+                if (fullCheckout) {
+                    if (auto zonePath = findZonePathForRepoPath(*manifest, repoPath)) {
+                        auto & info = tectonixDirtyZones[*zonePath];
+                        info.dirty = true;
+                        info.dirtyFiles.insert(repoPath);
+                    }
+                    continue;
+                }
+
                 for (auto & [zonePath, info] : tectonixDirtyZones) {
                     auto normalized = "/" + normalizeZonePath(zonePath);
                     if (hasPrefix(filePath, normalized + "/") || filePath == normalized) {
                         info.dirty = true;
-                        info.dirtyFiles.insert(filePath.substr(1));
+                        info.dirtyFiles.insert(repoPath);
                         break;
                     }
                 }
@@ -724,11 +802,21 @@ const std::map<std::string, EvalState::ZoneDirtyInfo> & EvalState::getTectonixDi
         size_t dirtyCount = 0;
         for (const auto & [_, info] : tectonixDirtyZones)
             if (info.dirty) dirtyCount++;
-        debug("computed dirty zones: %d of %d zones are dirty", dirtyCount, tectonixDirtyZones.size());
+        debug("computed dirty zones: %d of %d materialized zones are dirty", dirtyCount, tectonixDirtyZones.size());
     });
     return tectonixDirtyZones;
 }
 
+bool EvalState::isTectonixZoneDirty(std::string_view zonePath) const
+{
+    if (!isTectonixSourceAvailable())
+        return false;
+
+    auto & dirtyZones = getTectonixDirtyZones();
+    auto it = dirtyZones.find(std::string(zonePath));
+    return it != dirtyZones.end() && it->second.dirty;
+}
+
 // Path to the tectonix manifest file within the world repository
 static constexpr std::string_view TECTONIX_MANIFEST_PATH = "/.meta/manifest.json";
 
diff --git a/src/libexpr/include/nix/expr/eval.hh b/src/libexpr/include/nix/expr/eval.hh
@@ -530,6 +530,10 @@ private:
     /** Cache: world path → tree SHA (lazy computed, cached at each path level) */
     const ref<boost::concurrent_flat_map<std::string, Hash>> worldTreeShaCache;
 
+    /** Lazy-initialized full-checkout detection (thread-safe via once_flag) */
+    mutable std::once_flag tectonixFullCheckoutFlag;
+    mutable bool tectonixFullCheckout = false;
+
     /** Lazy-initialized set of zone IDs in sparse checkout (thread-safe via once_flag) */
     mutable std::once_flag tectonixSparseCheckoutRootsFlag;
     mutable std::set<std::string> tectonixSparseCheckoutRoots;
@@ -635,12 +639,18 @@ public:
     /** Check if we're in source-available mode */
     bool isTectonixSourceAvailable() const;
 
+    /** Check if source-available mode points at a non-sparse/full checkout */
+    bool isTectonixFullCheckout() const;
+
     /** Get set of zone IDs in sparse checkout (source-available mode only) */
     const std::set<std::string> & getTectonixSparseCheckoutRoots() const;
 
-    /** Get map of zone path → dirty status (only for sparse-checked-out zones) */
+    /** Get map of zone path → dirty status */
     const std::map<std::string, ZoneDirtyInfo> & getTectonixDirtyZones() const;
 
+    /** Check whether a zone has uncommitted changes in source-available mode */
+    bool isTectonixZoneDirty(std::string_view zonePath) const;
+
     /** Get cached manifest content (thread-safe, lazy-loaded) */
     const std::string & getManifestContent() const;
 
diff --git a/src/libexpr/primops/tectonix.cc b/src/libexpr/primops/tectonix.cc
@@ -260,12 +260,12 @@ static RegisterPrimOp primop_unsafeTectonixInternalDirtyZones({
     .name = "__unsafeTectonixInternalDirtyZones",
     .args = {},
     .doc = R"(
-      Get the dirty status of zones in the sparse checkout.
+      Get the dirty status of zones in the checkout.
 
       Returns an attrset mapping zone paths to booleans indicating whether
-      the zone has uncommitted changes.
-
-      Only includes zones that are in the sparse checkout.
+      the zone has uncommitted changes. Sparse checkouts include all sparse
+      roots with clean zones set to false. Full checkouts include dirty zones
+      only so the evaluator does not eagerly expand every zone.
 
       Example: `builtins.unsafeTectonixInternalDirtyZones."//areas/tools/dev"` returns `true` or `false`.
 
@@ -274,6 +274,26 @@ static RegisterPrimOp primop_unsafeTectonixInternalDirtyZones({
     .fun = prim_unsafeTectonixInternalDirtyZones,
 });
 
+// ============================================================================
+// builtins.__unsafeTectonixInternalFullCheckout
+// Returns whether source-available mode points at a non-sparse/full checkout
+// ============================================================================
+static void prim_unsafeTectonixInternalFullCheckout(EvalState & state, const PosIdx pos, Value ** args, Value & v)
+{
+    v.mkBool(state.isTectonixFullCheckout());
+}
+
+static RegisterPrimOp primop_unsafeTectonixInternalFullCheckout({
+    .name = "__unsafeTectonixInternalFullCheckout",
+    .args = {},
+    .doc = R"(
+      Return true when `--tectonix-checkout-path` points at a non-sparse/full
+      checkout (`core.sparseCheckout` unset or false). This lets Tectonix treat
+      zones as source-available without materializing a root entry for every zone.
+    )",
+    .fun = prim_unsafeTectonixInternalFullCheckout,
+});
+
 // ============================================================================
 // builtins.__unsafeTectonixInternalZoneIsDirty zonePath
 // Returns whether a given zone is dirty in the checkout
@@ -285,14 +305,7 @@ static void prim_unsafeTectonixInternalZoneIsDirty(EvalState & state, const PosI
 
     validateZonePath(state, pos, zonePath);
 
-    bool isDirty = false;
-    if (state.isTectonixSourceAvailable()) {
-        auto & dirtyZones = state.getTectonixDirtyZones();
-        auto it = dirtyZones.find(std::string(zonePath));
-        isDirty = it != dirtyZones.end() && it->second.dirty;
-    }
-
-    v.mkBool(isDirty);
+    v.mkBool(state.isTectonixZoneDirty(zonePath));
 }
 
 static RegisterPrimOp primop_unsafeTectonixInternalZoneIsDirty({
diff --git a/tests/functional/tectonix/dirty-zones.sh b/tests/functional/tectonix/dirty-zones.sh
@@ -10,6 +10,16 @@ HEAD_SHA=$(get_head_sha "$TEST_WORLD")
 
 echo "Testing dirty zone detection..."
 
+# Test worlds are regular/full checkouts unless sparse-checkout is explicitly enabled.
+full_checkout=$(tectonix_eval_json "$TEST_WORLD/.git" "$HEAD_SHA" \
+    'builtins.unsafeTectonixInternalFullCheckout' \
+    --option tectonix-checkout-path "$TEST_WORLD")
+echo "Full checkout status: $full_checkout"
+
+if [[ "$full_checkout" != "true" ]]; then
+    fail "Checkout should be detected as full when core.sparseCheckout is unset"
+fi
+
 # First, verify zone is clean
 zone_is_dirty=$(tectonix_eval_json "$TEST_WORLD/.git" "$HEAD_SHA" \
     'builtins.unsafeTectonixInternalZoneIsDirty "//areas/tools/dev"' \
@@ -56,4 +66,25 @@ if [[ "$clean_zone_dirty" == "true" ]]; then
     fail "Unmodified zone should not be dirty"
 fi
 
+# Enabling sparse checkout should flip the full-checkout detector while retaining
+# dirty-zone behavior via sparse-checkout-roots.
+git -C "$TEST_WORLD" config core.sparseCheckout true
+sparse_full_checkout=$(tectonix_eval_json "$TEST_WORLD/.git" "$HEAD_SHA" \
+    'builtins.unsafeTectonixInternalFullCheckout' \
+    --option tectonix-checkout-path "$TEST_WORLD")
+echo "Sparse checkout full status: $sparse_full_checkout"
+
+if [[ "$sparse_full_checkout" != "false" ]]; then
+    fail "Checkout should not be detected as full when core.sparseCheckout=true"
+fi
+
+sparse_zone_dirty=$(tectonix_eval_json "$TEST_WORLD/.git" "$HEAD_SHA" \
+    'builtins.unsafeTectonixInternalZoneIsDirty "//areas/tools/dev"' \
+    --option tectonix-checkout-path "$TEST_WORLD")
+echo "Sparse dirty zone status: $sparse_zone_dirty"
+
+if [[ "$sparse_zone_dirty" != "true" ]]; then
+    fail "Sparse dirty zone should still be dirty after enabling sparse checkout"
+fi
+
 echo "Dirty zone tests passed!"
