libcmd: honor AutoCall for flake installables

`InstallableFlake::getCursors()` ignored its `AutoCall` argument, so a
flake output that is a function was handed to `nix run`, `nix search`,
`nix bundle` and `nix repl` uncalled, and they failed on it instead of
applying it to its default arguments.

Auto-call the cursor when the caller asks for it. The auto-called value
generally differs from the one at that attribute path, so it gets its own
slot in the evaluation cache, recorded as a `<auto-call>` pseudo-attribute
of the cursor. Sharing the attribute's own key would let a later
`AutoCall::No` lookup pick up the auto-called result rather than failing
on the function. The call itself happens lazily, when the cursor's value
is first needed, so cached attributes are still served without evaluating
anything.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_014Curu4eZVEzFJZnA7ZADPz

Author: domenkozar

src/libcmd/installable-flake.cc

@@ -146,7 +146,7 @@ std::pair<Value *, PosIdx> InstallableFlake::toValue(EvalState & state, AutoCall
     return {&getCursor(state, autoCall)->forceValue(), noPos};
 }
 
-std::vector<ref<eval_cache::AttrCursor>> InstallableFlake::getCursors(EvalState & state, AutoCall)
+std::vector<ref<eval_cache::AttrCursor>> InstallableFlake::getCursors(EvalState & state, AutoCall autoCall)
 {
     auto evalCache = openEvalCache(state, getLockedFlake());
 
@@ -163,7 +163,7 @@ std::vector<ref<eval_cache::AttrCursor>> InstallableFlake::getCursors(EvalState
         try {
             auto attr = root->findAlongAttrPath(AttrPath::parse(state, attrPath));
             if (attr) {
-                res.push_back(ref(*attr));
+                res.push_back(autoCall == AutoCall::Yes ? (*attr)->autoCall() : ref(*attr));
             } else {
                 suggestions += attr.getSuggestions();
             }

src/libexpr/eval-cache.cc

@@ -374,10 +374,15 @@ ref<AttrCursor> EvalCache::getRoot()
 }
 
 AttrCursor::AttrCursor(
-    ref<EvalCache> root, Parent parent, Value * value, std::optional<std::pair<AttrId, AttrValue>> && cachedValue)
+    ref<EvalCache> root,
+    Parent parent,
+    Value * value,
+    std::optional<std::pair<AttrId, AttrValue>> && cachedValue,
+    bool autoCalled)
     : root(root)
     , parent(parent)
     , cachedValue(std::move(cachedValue))
+    , autoCalled(autoCalled)
 {
     if (value)
         _value = allocRootValue(value);
@@ -397,7 +402,12 @@ AttrKey AttrCursor::getKey()
 Value & AttrCursor::getValue()
 {
     if (!_value) {
-        if (parent) {
+        if (autoCalled) {
+            assert(parent);
+            auto * result = root->state.allocValue();
+            root->state.autoCallFunction(Bindings::emptyBindings, parent->first->forceValue(), *result);
+            _value = allocRootValue(result);
+        } else if (parent) {
             auto & vParent = parent->first->getValue();
             root->state.forceAttrs(vParent, noPos, "while searching for an attribute");
             auto attr = vParent.attrs()->get(parent->second);
@@ -422,7 +432,10 @@ AttrPath AttrCursor::getAttrPath() const
 {
     if (parent) {
         auto attrPath = parent->first->getAttrPath();
-        attrPath.push_back(parent->second);
+        /* The auto-call slot is an implementation detail, so it doesn't
+           show up in the user-visible attribute path. */
+        if (!autoCalled)
+            attrPath.push_back(parent->second);
         return attrPath;
     } else
         return {};
@@ -455,7 +468,10 @@ Value & AttrCursor::forceValue()
         root->state.forceValue(v, noPos);
     } catch (EvalError &) {
         debug("setting '%s' to failed", getAttrPathStr());
-        if (root->db)
+        /* An auto-call is not an attribute of its parent, so
+           `CachedEvalError::force()` could not reproduce the original
+           error from a cached failure. Just don't cache it. */
+        if (root->db && !autoCalled)
             cachedValue = {root->db->setFailed(getKey()), failed_t()};
         throw;
     }
@@ -757,6 +773,31 @@ bool AttrCursor::isDerivation()
     return aType && aType->getString() == "derivation";
 }
 
+ref<AttrCursor> AttrCursor::autoCall()
+{
+    /* The auto-called value generally differs from the one at this
+       attribute path, so it gets its own slot in the evaluation cache,
+       recorded as a pseudo-attribute of this cursor. (A flake output
+       actually named `<auto-call>` would collide, but only if it is a
+       function, in which case it has no attributes of its own anyway.) */
+    auto name = root->state.symbols.create("<auto-call>");
+
+    std::optional<std::pair<AttrId, AttrValue>> cachedValue2;
+
+    if (root->db) {
+        fetchCachedValue();
+        if (!cachedValue)
+            cachedValue = {root->db->setPlaceholder(getKey()), placeholder_t()};
+        AttrKey key{cachedValue->first, name};
+        cachedValue2 = root->db->getAttr(key);
+        if (!cachedValue2)
+            cachedValue2 = {root->db->setPlaceholder(key), placeholder_t()};
+    }
+
+    return make_ref<AttrCursor>(
+        root, std::make_pair(ref(shared_from_this()), name), nullptr, std::move(cachedValue2), true);
+}
+
 StorePath AttrCursor::forceDerivation()
 {
     auto aDrvPath = getAttr(root->state.s.drvPath);

src/libexpr/include/nix/expr/eval-cache.hh

@@ -108,6 +108,12 @@ class AttrCursor : public std::enable_shared_from_this<AttrCursor>
     RootValue _value;
     std::optional<std::pair<AttrId, AttrValue>> cachedValue;
 
+    /**
+     * Whether this cursor holds the result of auto-calling its parent
+     * (see `autoCall()`) rather than one of its parent's attributes.
+     */
+    bool autoCalled = false;
+
     AttrKey getKey();
 
     Value & getValue();
@@ -126,7 +132,8 @@ public:
         ref<EvalCache> root,
         Parent parent,
         Value * value = nullptr,
-        std::optional<std::pair<AttrId, AttrValue>> && cachedValue = {});
+        std::optional<std::pair<AttrId, AttrValue>> && cachedValue = {},
+        bool autoCalled = false);
 
     AttrPath getAttrPath() const;
 
@@ -168,6 +175,18 @@ public:
 
     Value & forceValue();
 
+    /**
+     * Return a cursor for this value, auto-called with no automatic
+     * arguments if it is a function (see `EvalState::autoCallFunction()`).
+     * The returned cursor keeps this cursor's attribute path, but gets its
+     * own slot in the evaluation cache, since auto-calling generally
+     * yields a value other than the one at that path.
+     *
+     * The call happens lazily, when the cursor's value is first needed, so
+     * cached attributes are still served without evaluating anything.
+     */
+    ref<AttrCursor> autoCall();
+
     /**
      * Force creation of the .drv file in the Nix store.
      */

tests/functional/flakes/bundle.sh

@@ -17,6 +17,7 @@ cat <<EOF > flake.nix
         default = simple;
       };
       packages.$system.default = import ./simple.nix;
+      packages.$system.functionPackage = {}: import ./simple.nix;
       apps.$system.default = {
         type = "app";
         program = "\${import ./simple.nix}/hello";
@@ -29,6 +30,7 @@ nix build .#
 nix bundle --bundler .# .#
 nix bundle --bundler .#bundlers."$system".default .#packages."$system".default
 nix bundle --bundler .#bundlers."$system".simple  .#packages."$system".default
+nix bundle --bundler .#bundlers."$system".simple  .#packages."$system".functionPackage
 
 nix bundle --bundler .#bundlers."$system".default .#apps."$system".default
 nix bundle --bundler .#bundlers."$system".simple  .#apps."$system".default

tests/functional/flakes/eval-cache.sh

@@ -48,3 +48,33 @@ nix build --no-link "$flake1Dir#stack-depth"
 expect 1 nix build "$flake1Dir#ifd" --option allow-import-from-derivation false 2>&1 \
   | grepQuiet 'error: cannot build .* during evaluation because the option '\''allow-import-from-derivation'\'' is disabled'
 nix build --no-link "$flake1Dir#ifd"
+
+# Commands that auto-call the installable ('nix search', 'nix run', ...) must
+# still use the cache: the trace fires while the cache is cold, and never again.
+flake2Dir="$TEST_ROOT/eval-cache-auto-call-flake"
+
+createGitRepo "$flake2Dir" ""
+cp ../simple.nix ../simple.builder.sh "${config_nix}" "$flake2Dir/"
+git -C "$flake2Dir" add simple.nix simple.builder.sh config.nix
+
+cat >"$flake2Dir/flake.nix" <<EOF
+{
+  outputs = { self }: let inherit (import ./config.nix) mkDerivation; in {
+    legacyPackages.$system = {};
+    packages.$system = builtins.trace "evaluating packages" {
+      cached = mkDerivation {
+        name = "cached";
+        buildCommand = ''
+          echo true > \$out
+        '';
+      };
+    };
+  };
+}
+EOF
+
+git -C "$flake2Dir" add flake.nix
+git -C "$flake2Dir" commit -m "Init"
+
+nix search --no-write-lock-file "$flake2Dir" ^ 2>&1 | grepQuiet "evaluating packages"
+nix search --no-write-lock-file "$flake2Dir" ^ 2>&1 | grepQuietInverse "evaluating packages"

tests/functional/flakes/run.sh

@@ -18,11 +18,16 @@ cat <<EOF > flake.nix
         type = "app";
         program = "\${(import ./shell-hello.nix).hello}/bin/hello";
       };
+      apps.$system.functionApp = {}: {
+        type = "app";
+        program = "\${(import ./shell-hello.nix).hello}/bin/hello";
+      };
     };
 }
 EOF
 nix run --no-write-lock-file .#appAsApp
 nix run --no-write-lock-file .#pkgAsPkg
+nix run --no-write-lock-file .#functionApp
 
 ! nix run --no-write-lock-file .#pkgAsApp || fail "'nix run' shouldn’t accept an 'app' defined under 'packages'"
 ! nix run --no-write-lock-file .#appAsPkg || fail "elements of 'apps' should be of type 'app'"
@@ -87,4 +92,3 @@ nix run --no-write-lock-file -- . myarg1 myarg2 2>&1 | grepQuiet "ARGS: myarg1 m
 
 # And verify that a non-installable first argument causes an error
 expectStderr 1 nix run --no-write-lock-file -- myarg1 myarg2 | grepQuiet "error.*myarg1"
-

tests/functional/search.sh

@@ -46,3 +46,16 @@ e=$'\x1b' # grep doesn't support \e, \033 or even \x1b
 (( $(nix search -f search.nix foo ^ --exclude 'foo|bar' | grep -Ec 'foo|bar') == 0 ))
 (( $(nix search -f search.nix foo ^ -e foo --exclude bar | grep -Ec 'foo|bar') == 0 ))
 [[ $(nix search -f search.nix '' ^ -e bar --json | jq -c 'keys') == '["foo","hello"]' ]]
+
+# Flake installables with function-valued package sets are auto-called.
+flakeDir="$TEST_HOME/function-flake"
+mkdir "$flakeDir"
+cp search.nix "$config_nix" "$flakeDir"
+cat > "$flakeDir/flake.nix" <<EOF
+{
+  outputs = { self }: {
+    packages.$system = {}: import ./search.nix;
+  };
+}
+EOF
+nix search "$flakeDir" hello | grepQuiet hello