we tried pretty much exactly this before giving up and copying subdirectories explicitly, since it doesn't seem to work:

locking path '/nix/store/0n8zdf8sn8hk1pdqczgczz09gf8rcx97-mf2c1hpfds2fv501d1jc6pxc07qym974-nixpkgs'
lock acquired on '/nix/store/0n8zdf8sn8hk1pdqczgczz09gf8rcx97-mf2c1hpfds2fv501d1jc6pxc07qym974-nixpkgs.lock'
'/nix/store/0n8zdf8sn8hk1pdqczgczz09gf8rcx97-mf2c1hpfds2fv501d1jc6pxc07qym974-nixpkgs/.editorconfig' has hash 'sha256:1wkj2wfy26ylp3dbrhbiw71y9fci11mbi8pj7zsdw8i1xncll2g3'
linking '/nix/store/0n8zdf8sn8hk1pdqczgczz09gf8rcx97-mf2c1hpfds2fv501d1jc6pxc07qym974-nixpkgs/.editorconfig' to '/nix/store/.links/1wkj2wfy26ylp3dbrhbiw71y9fci11mbi8pj7zsdw8i1xncll2g3'
'/nix/store/0n8zdf8sn8hk1pdqczgczz09gf8rcx97-mf2c1hpfds2fv501d1jc6pxc07qym974-nixpkgs/.git/HEAD' has hash 'sha256:0fq06xi94yqqr4snhcgax31da3rmyzd0wm6804xgks8psjgrr4wf'
[ repeat for all of nixpkgs ]

the only way to avoid having a redundant copy is to force the name of the resulting store path to be the same as the source store path (eg, path { name = "source"; path = pkgs.path; }), but that only avoids the duplication, not the copy. all the hashing and comparing will still take place, at which point it's much cheaper to only copy the necessary directories.

the resulting drv for lazy-options starts like this:

❯ nix show-derivation /nix/store/k5mzim7l3rdh02xpflgks82cb6scdbrn-lazy-options.json.drv
{
  "/nix/store/k5mzim7l3rdh02xpflgks82cb6scdbrn-lazy-options.json.drv": {
    "outputs": {
      "out": {
        "path": "/nix/store/lrzp2dipfv773wvf4mr5lk2rfrj2r07i-lazy-options.json"
      }
    },
    "inputSrcs": [
      "/nix/store/0n8zdf8sn8hk1pdqczgczz09gf8rcx97-mf2c1hpfds2fv501d1jc6pxc07qym974-nixpkgs",
      "/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh"
    ],

Was that without the flake?

With the flake, it should use outPath, which is a string with context, so that should be efficient.
Without the flake, it defaults to a path is a "path value" such that isStorePath path == false, at least when using a local checkout. I think this is where it went wrong? Or maybe I was holding it wrong again.

I've pushed a commit. It's really kind of a flake-only optimization now, unless someone cares to set config.path.

yes, that was without flakes, we ran nix-instantiate -vvvvv /nix/store/mf2c1hpfds2fv501d1jc6pxc07qym974-nixpkgs/nixos -A config.system.build.manual, where the store path in there was a freshly added checkout of your branch. hadn't even checked the flake case because we remembered the non-flake case would suffer.

checked the flake case with your additional commit now though, and we still see a lot of copying happening:

{
  "/nix/store/6gjsp6s79qggw0sz9lnbl2bin8lhd6pq-lazy-options.json.drv": {
    "outputs": {
      "out": {
        "path": "/nix/store/za8h4fvkrnvyyrsf4936scfwq6afmad0-lazy-options.json"
      }
    },
    "inputSrcs": [
      "/nix/store/6b1v21x04fxr6w84nl8424xd2x6r304g-lib",
      "/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh",
      "/nix/store/an5jjcrjay229b0kfckyza3dnfif0kzh-nixos",
      "/nix/store/ns935b2vvx5i7hwmlz8c8bdxz1frhhxm-pkgs-lib"
    ],

not sure there's a good way to solve this if builtins.storePath isn't available from pure evaluations. the best we can think of right now is to inject a differentiator from the flake: if it's not present use storePath, if it is present pull lazy-options.json from a nixpkgs flake output that contains exactly the derivation required to build lazy-options

"inputSrcs": [
      "/nix/store/6b1v21x04fxr6w84nl8424xd2x6r304g-lib",
      "/nix/store/9krlzvny65gdc8s7kpb6lkx8cd02c25b-default-builder.sh",
      "/nix/store/an5jjcrjay229b0kfckyza3dnfif0kzh-nixos",
      "/nix/store/ns935b2vvx5i7hwmlz8c8bdxz1frhhxm-pkgs-lib"
    ],

This looks as expected for a non-flake eval. Without builtins.storePath we can't do better.

the best we can think of right now is to inject a differentiator from the flake

That's kind of what's happening after my last commit here, except it errs on the safe side, rather than assuming pure eval is off for non-flake usage.

It's not as good as we hoped, but at least it doesn't break and is more efficient for flake users.

This looks as expected for a non-flake eval.

that was a flake eval though 🙁

test operations done to get to that conclusion:

nix show-derivation $(nix eval --raw .\#nixosConfigurations.$(hostname).config.system.build.manual.optionsJSON --override-input nixpkgs github:hercules-ci/nixpkgs/flake-avoid-copying-nixpkgs-path)
# find the layz-options.json drv
nix show-derivation $that_drv # here: /nix/store/zga6r1jkxbrklp25s90x8iz1nyxb96qw-lazy-options.json.drv

we've confirmed that the eval did use your repo, our current flake lock for the test system does not include the docs split yet

pkgs isn't a legacyPackages. The latest commit sets config.path in NixOS-initialized Nixpkgs.

we finally got around to checking whether getEnv really is viable for this, and it is! 🙂 since PATH should always be set to something getEnv "PATH" != "" is a pretty good approximation of a hypothetical isImpureEval, so we can use storePath to avoid copies as well. here's a patch, we would've added it to the branch (and attempted to rebase) but that seems to be disallowed for this PR.

diff --git a/nixos/modules/misc/documentation.nix b/nixos/modules/misc/documentation.nix
index 2ecdf68293e..b850d5f9ab5 100644
--- a/nixos/modules/misc/documentation.nix
+++ b/nixos/modules/misc/documentation.nix
@@ -74,13 +74,18 @@ let
         #
         # We can only avoid copying when pkgs.path is already a string. A path
         # value can not be converted to a store path without rehashing it.
-        # builtins.storePath would be a solution but is currently off-limits
-        # because of https://github.com/NixOS/nix/issues/1888
-        #        and https://github.com/NixOS/nix/issues/5868
-        pull = dir:
-          if builtins.typeOf pkgs.path == "string" && isStorePath pkgs.path
-          then "${pkgs.path}/${dir}"
-          else filter "${toString pkgs.path}/${dir}";
+        # builtins.storePath can only be used to avoid this when impure eval is
+        # allowed, which we approximate by getEnv returning something for a
+        # variable that should always be set.
+        # see https://github.com/NixOS/nix/issues/1888
+        # and https://github.com/NixOS/nix/issues/5868
+        pull =
+          if builtins.typeOf pkgs.path == "string" && isStorePath pkgs.path then
+            dir: "${pkgs.path}/${dir}"
+          else if builtins.getEnv "PATH" != "" && isStorePath pkgs.path then
+            dir: "${builtins.storePath pkgs.path}/${dir}"
+          else
+            dir: filter "${toString pkgs.path}/${dir}";
       in
         pkgs.runCommand "lazy-options.json" {
           libPath = pull "lib";

we like this a lot. thanks for caring and for writing the extremely comprehensive comments, they're superb :)

tested it again, the copy elision seems to work fine, resulting json also looks good.

Note that this makes nix-env produce a different evaluation result for a nixpkgs tree inside the Nix store compared to one outside of the Nix store, because the nixos-install-tools attribute will be different. That's an undesirable property IMHO (see #156527 and #156587).

In general we should avoid the use of isStorePath on sources since they cause divergent evaluation results. Perhaps we should ensure that builtins.isStorePath is false for inputs to the evaluator, even when the inputs happen to be in the store.

I agree that this is still not a great solution. Indeed this will produce one of two different derivations depending on how the NixOS/Nixpkgs invocation was made. Perhaps the filterSource based invocation shouldn't be automatic? That will make the drvs reproducible again.

I've reverted this PR, as it makes already fragile code like the installer tests even more fragile.