lib: add builtins prefixes for prelude functions to improve clarity

lib/fileset/default.nix

···
     `gitTrackedWith` does not perform any filtering when the path is a [Nix store path](https://nixos.org/manual/nix/stable/store/store-path.html#store-path) and not a repository.
     In this way, it accommodates the use case where the expression that makes the `gitTracked` call does not reside in an actual git repository anymore,
     and has presumably already been fetched in a way that excludes untracked files.
-    Fetchers with such equivalent behavior include `fetchGit`, `fetchTree` (experimental), and `pkgs.fetchgit` when used without `leaveDotGit`.
+    Fetchers with such equivalent behavior include `builtins.fetchGit`, `builtins.fetchTree` (experimental), and `pkgs.fetchgit` when used without `leaveDotGit`.
 
     If you don't need the configuration,
     you can use [`gitTracked`](#function-library-lib.fileset.gitTracked) instead.
···
     (which uses [`--cached`](https://git-scm.com/docs/git-ls-files#Documentation/git-ls-files.txt--c) by default).
 
     :::{.warning}
-    Currently this function is based on [`fetchGit`](https://nixos.org/manual/nix/stable/language/builtins.html#builtins-fetchGit)
+    Currently this function is based on [`builtins.fetchGit`](https://nixos.org/manual/nix/stable/language/builtins.html#builtins-fetchGit)
     As such, this function causes all Git-tracked files to be unnecessarily added to the Nix store,
     without being re-usable by [`toSource`](#function-library-lib.fileset.toSource).
 

lib/fileset/internal.nix

···
           throw ''
             lib.fileset.${function}: The ${argument} (${toString path}) is a store path within a working tree of a Git repository.
                 This indicates that a source directory was imported into the store using a method such as `import "''${./.}"` or `path:.`.
-                This function currently does not support such a use case, since it currently relies on `fetchGit`.
+                This function currently does not support such a use case, since it currently relies on `builtins.fetchGit`.
                 You could make this work by using a fetcher such as `fetchGit` instead of copying the whole repository.
                 If you can't avoid copying the repo to the store, see https://github.com/NixOS/nix/issues/9292.''
         else
           # Otherwise we're going to assume that the path was a Git directory originally,
           # but it was fetched using a method that already removed files not tracked by Git,
-          # such as `fetchGit`, `pkgs.fetchgit` or others.
+          # such as `builtins.fetchGit`, `pkgs.fetchgit` or others.
           # So we can just import the path in its entirety.
           _singleton path;
 
···
       tryFetchGit =
         let
           # This imports the files unnecessarily, which currently can't be avoided
-          # because `fetchGit` is the only function exposing which files are tracked by Git.
+          # because `builtins.fetchGit` is the only function exposing which files are tracked by Git.
           # With the [lazy trees PR](https://github.com/NixOS/nix/pull/6530),
           # the unnecessarily import could be avoided.
           # However a simpler alternative still would be [a builtins.gitLsFiles](https://github.com/NixOS/nix/issues/2944).
···
         in
         # We can identify local working directories by checking for .git,
         # see https://git-scm.com/docs/gitrepository-layout#_description.
-        # Note that `fetchGit` _does_ work for bare repositories (where there's no `.git`),
+        # Note that `builtins.fetchGit` _does_ work for bare repositories (where there's no `.git`),
         # even though `git ls-files` wouldn't return any files in that case.
         if !pathExists (path + "/.git") then
           throw "lib.fileset.${function}: Expected the ${argument} (${toString path}) to point to a local working tree of a Git repository, but it's not."

lib/fileset/tests.sh

···
 ## But it fails if the path is imported with a fetcher that doesn't remove .git (like just using "${./.}")
 expectFailure 'import "${./.}" { fs = lib.fileset; }' 'lib.fileset.gitTracked: The argument \(.*\) is a store path within a working tree of a Git repository.
 [[:blank:]]*This indicates that a source directory was imported into the store using a method such as `import "\$\{./.\}"` or `path:.`.
-[[:blank:]]*This function currently does not support such a use case, since it currently relies on `fetchGit`.
+[[:blank:]]*This function currently does not support such a use case, since it currently relies on `builtins.fetchGit`.
 [[:blank:]]*You could make this work by using a fetcher such as `fetchGit` instead of copying the whole repository.
 [[:blank:]]*If you can'\''t avoid copying the repo to the store, see https://github.com/NixOS/nix/issues/9292.'
 
···
 ## But it fails if the path is imported with a fetcher that doesn't remove .git (like just using "${./.}")
 expectFailure 'import "${./.}" { fs = lib.fileset; }' 'lib.fileset.gitTrackedWith: The second argument \(.*\) is a store path within a working tree of a Git repository.
 [[:blank:]]*This indicates that a source directory was imported into the store using a method such as `import "\$\{./.\}"` or `path:.`.
-[[:blank:]]*This function currently does not support such a use case, since it currently relies on `fetchGit`.
+[[:blank:]]*This function currently does not support such a use case, since it currently relies on `builtins.fetchGit`.
 [[:blank:]]*You could make this work by using a fetcher such as `fetchGit` instead of copying the whole repository.
 [[:blank:]]*If you can'\''t avoid copying the repo to the store, see https://github.com/NixOS/nix/issues/9292.'
 expectFailure 'import "${./.}/sub" { fs = lib.fileset; }' 'lib.fileset.gitTracked: The argument \(.*/sub\) is a store path within a working tree of a Git repository.
 [[:blank:]]*This indicates that a source directory was imported into the store using a method such as `import "\$\{./.\}"` or `path:.`.
-[[:blank:]]*This function currently does not support such a use case, since it currently relies on `fetchGit`.
+[[:blank:]]*This function currently does not support such a use case, since it currently relies on `builtins.fetchGit`.
 [[:blank:]]*You could make this work by using a fetcher such as `fetchGit` instead of copying the whole repository.
 [[:blank:]]*If you can'\''t avoid copying the repo to the store, see https://github.com/NixOS/nix/issues/9292.'
 rm -rf -- *

lib/path/README.md

···
 - (-) `./.` is rather long.
   - (-) We don't require users to type this though, as it's only output by the library.
     As inputs all three variants are supported for subpaths (and we can't do anything about absolute paths)
-- (-) `dirOf "foo" == "."`, so `.` would be consistent with that.
+- (-) `builtins.dirOf "foo" == "."`, so `.` would be consistent with that.
 - (+) `./.` is consistent with the [decision to have leading `./`][leading-dots].
 - (+) `./.` is a valid Nix path expression, although this property does not hold for every relative path or subpath.
 

lib/tests/misc.nix

···
   testPackagesFromDirectoryRecursiveStringDirectory = {
     expr = packagesFromDirectoryRecursive {
       callPackage = path: overrides: import path overrides;
-      # Do NOT remove the `toString` call here!!!
+      # Do NOT remove the `builtins.toString` call here!!!
       directory = toString ./packages-from-directory/plain;
     };
     expected = {