libexpr: add builtins.filterAttrs with tombstone optimization

Add a new builtin function filterAttrs that filters attribute sets based
on a predicate function. The predicate receives both the attribute name
and value, returning true for attributes to keep.

Implementation uses tombstones for large attrsets (>= 8 elements) when
layer capacity is available. Instead of copying all matching attributes,
it layers tombstones for non-matching attributes on top of the source.
This is beneficial when most attributes pass the filter (common case).

Fast paths:
- Empty attrset: return unchanged
- All attributes pass: return unchanged
- No attributes pass: return emptyBindings

Falls back to copy-based approach for small attrsets or when the
layer list is full.

Example usage:
  builtins.filterAttrs (name: value: value > 5) { a = 3; b = 6; c = 10; }
  => { b = 6; c = 10; }

Author: philiptaron

src/libexpr/primops.cc

@@ -3565,6 +3565,93 @@ static RegisterPrimOp primop_mapAttrs({
     .fun = prim_mapAttrs,
 });
 
+static void prim_filterAttrs(EvalState & state, const PosIdx pos, Value ** args, Value & v)
+{
+    state.forceAttrs(*args[1], pos, "while evaluating the second argument passed to builtins.filterAttrs");
+
+    auto * source = args[1]->attrs();
+
+    // Fast path: empty attrset
+    if (source->empty()) {
+        v = *args[1];
+        return;
+    }
+
+    state.forceFunction(*args[0], pos, "while evaluating the first argument passed to builtins.filterAttrs");
+
+    // For large attrsets with available layer capacity, use tombstones.
+    // This is beneficial when most attrs pass the filter (common case).
+    constexpr size_t tombstoneThreshold = 8;
+    if (source->size() >= tombstoneThreshold && !source->isLayerListFull()) {
+        // Collect attrs that DON'T pass the filter (will become tombstones)
+        boost::container::small_vector<Symbol, 64> toRemove;
+
+        for (auto & attr : *source) {
+            Value * vName = Value::toPtr(state.symbols[attr.name]);
+            Value * callArgs[] = {vName, attr.value};
+            Value res;
+            state.callFunction(*args[0], callArgs, res, noPos);
+            if (!state.forceBool(
+                    res,
+                    pos,
+                    "while evaluating the return value of the filtering function passed to builtins.filterAttrs"))
+                toRemove.push_back(attr.name);
+        }
+
+        // If nothing to remove, return original
+        if (toRemove.empty()) {
+            v = *args[1];
+            return;
+        }
+
+        // If everything filtered out, return empty
+        if (toRemove.size() == source->size()) {
+            v.mkAttrs(&Bindings::emptyBindings);
+            return;
+        }
+
+        // Layer tombstones on top
+        auto attrs = state.buildBindings(toRemove.size());
+        for (auto sym : toRemove)
+            attrs.insertTombstone(sym);
+        attrs.layerOnTopOf(*source);
+        v.mkAttrs(attrs.finish());
+        return;
+    }
+
+    // Copy approach for small attrsets or when layer list is full
+    auto attrs = state.buildBindings(source->size());
+
+    for (auto & attr : *source) {
+        Value * vName = Value::toPtr(state.symbols[attr.name]);
+        Value * callArgs[] = {vName, attr.value};
+        Value res;
+        state.callFunction(*args[0], callArgs, res, noPos);
+        if (state.forceBool(
+                res, pos, "while evaluating the return value of the filtering function passed to builtins.filterAttrs"))
+            attrs.insert(attr.name, attr.value);
+    }
+
+    v.mkAttrs(attrs.alreadySorted());
+}
+
+static RegisterPrimOp primop_filterAttrs({
+    .name = "__filterAttrs",
+    .args = {"f", "attrset"},
+    .doc = R"(
+      Return an attribute set consisting of the attributes in *attrset* for which
+      the function *f* returns `true`. The function *f* is called with two arguments:
+      the name of the attribute and the value of the attribute. For example,
+
+      ```nix
+      builtins.filterAttrs (name: value: name == "foo") { foo = 1; bar = 2; }
+      ```
+
+      evaluates to `{ foo = 1; }`.
+    )",
+    .fun = prim_filterAttrs,
+});
+
 static void prim_zipAttrsWith(EvalState & state, const PosIdx pos, Value ** args, Value & v)
 {
     // we will first count how many values are present for each given key.

tests/functional/lang/eval-okay-filterattrs-names.exp

@@ -0,0 +1 @@
+{ a = 3; }

tests/functional/lang/eval-okay-filterattrs-names.nix

@@ -0,0 +1,5 @@
+builtins.filterAttrs (name: value: name == "a") {
+  a = 3;
+  b = 6;
+  c = 10;
+}

tests/functional/lang/eval-okay-filterattrs.exp

@@ -0,0 +1 @@
+{ b = 6; c = 10; }

tests/functional/lang/eval-okay-filterattrs.nix

@@ -0,0 +1,5 @@
+builtins.filterAttrs (name: value: value > 5) {
+  a = 3;
+  b = 6;
+  c = 10;
+}