treewide: Format all Nix files

Format all Nix files using the officially approved formatter,
making the CI check introduced in the previous commit succeed:

  nix-build ci -A fmt.check

This is the next step of the of the [implementation](NixOS/nixfmt#153)
of the accepted [RFC 166](NixOS/rfcs#166).

This commit will lead to merge conflicts for a number of PRs,
up to an estimated ~1100 (~33%) among the PRs with activity in the past 2
months, but that should be lower than what it would be without the previous
[partial treewide format](NixOS/nixpkgs#322537).

Merge conflicts caused by this commit can now automatically be resolved while rebasing using the
[auto-rebase script](https://github.com/NixOS/nixpkgs/tree/8616af08d915377bd930395f3b700a0e93d08728/maintainers/scripts/auto-rebase).

If you run into any problems regarding any of this, please reach out to the
[formatting team](https://nixos.org/community/teams/formatting/) by
pinging @NixOS/nix-formatting.

Author: infinisil

lib/attrsets.nix

@@ -59,23 +59,26 @@ in
   pathType =
     builtins.readFileType or
     # Nix <2.14 compatibility shim
-    (path:
-      if ! pathExists path
+    (
+      path:
+      if
+        !pathExists path
       # Fail irrecoverably to mimic the historic behavior of this function and
       # the new builtins.readFileType
-      then abort "lib.filesystem.pathType: Path ${toString path} does not exist."
+      then
+        abort "lib.filesystem.pathType: Path ${toString path} does not exist."
       # The filesystem root is the only path where `dirOf / == /` and
       # `baseNameOf /` is not valid. We can detect this and directly return
       # "directory", since we know the filesystem root can't be anything else.
-      else if dirOf path == path
-      then "directory"
-      else (readDir (dirOf path)).${baseNameOf path}
+      else if dirOf path == path then
+        "directory"
+      else
+        (readDir (dirOf path)).${baseNameOf path}
     );
 
   /**
     Whether a path exists and is a directory.
 
-
     # Inputs
 
     `path`
@@ -105,13 +108,11 @@ in
 
     :::
   */
-  pathIsDirectory = path:
-    pathExists path && pathType path == "directory";
+  pathIsDirectory = path: pathExists path && pathType path == "directory";
 
   /**
     Whether a path exists and is a regular file, meaning not a symlink or any other special file type.
 
-
     # Inputs
 
     `path`
@@ -141,15 +142,13 @@ in
 
     :::
   */
-  pathIsRegularFile = path:
-    pathExists path && pathType path == "regular";
+  pathIsRegularFile = path: pathExists path && pathType path == "regular";
 
   /**
     A map of all haskell packages defined in the given path,
     identified by having a cabal file with the same name as the
     directory itself.
 
-
     # Inputs
 
     `root`
@@ -164,25 +163,25 @@ in
   */
   haskellPathsInDir =
     root:
-    let # Files in the root
-        root-files = builtins.attrNames (builtins.readDir root);
-        # Files with their full paths
-        root-files-with-paths =
-          map (file:
-            { name = file; value = root + "/${file}"; }
-          ) root-files;
-        # Subdirectories of the root with a cabal file.
-        cabal-subdirs =
-          builtins.filter ({ name, value }:
-            builtins.pathExists (value + "/${name}.cabal")
-          ) root-files-with-paths;
-    in builtins.listToAttrs cabal-subdirs;
+    let
+      # Files in the root
+      root-files = builtins.attrNames (builtins.readDir root);
+      # Files with their full paths
+      root-files-with-paths = map (file: {
+        name = file;
+        value = root + "/${file}";
+      }) root-files;
+      # Subdirectories of the root with a cabal file.
+      cabal-subdirs = builtins.filter (
+        { name, value }: builtins.pathExists (value + "/${name}.cabal")
+      ) root-files-with-paths;
+    in
+    builtins.listToAttrs cabal-subdirs;
   /**
     Find the first directory containing a file matching 'pattern'
     upward from a given 'file'.
     Returns 'null' if no directories contain a file matching 'pattern'.
 
-
     # Inputs
 
     `pattern`
@@ -200,30 +199,33 @@ in
     ```
   */
   locateDominatingFile =
-    pattern:
-    file:
-    let go = path:
-          let files = builtins.attrNames (builtins.readDir path);
-              matches = builtins.filter (match: match != null)
-                          (map (builtins.match pattern) files);
-          in
-            if builtins.length matches != 0
-              then { inherit path matches; }
-              else if path == /.
-                then null
-                else go (dirOf path);
-        parent = dirOf file;
-        isDir =
-          let base = baseNameOf file;
-              type = (builtins.readDir parent).${base} or null;
-          in file == /. || type == "directory";
-    in go (if isDir then file else parent);
-
+    pattern: file:
+    let
+      go =
+        path:
+        let
+          files = builtins.attrNames (builtins.readDir path);
+          matches = builtins.filter (match: match != null) (map (builtins.match pattern) files);
+        in
+        if builtins.length matches != 0 then
+          { inherit path matches; }
+        else if path == /. then
+          null
+        else
+          go (dirOf path);
+      parent = dirOf file;
+      isDir =
+        let
+          base = baseNameOf file;
+          type = (builtins.readDir parent).${base} or null;
+        in
+        file == /. || type == "directory";
+    in
+    go (if isDir then file else parent);
 
   /**
     Given a directory, return a flattened list of all files within it recursively.
 
-
     # Inputs
 
     `dir`
@@ -238,12 +240,15 @@ in
   */
   listFilesRecursive =
     dir:
-    lib.flatten (lib.mapAttrsToList (name: type:
-    if type == "directory" then
-      lib.filesystem.listFilesRecursive (dir + "/${name}")
-    else
-      dir + "/${name}"
-  ) (builtins.readDir dir));
+    lib.flatten (
+      lib.mapAttrsToList (
+        name: type:
+        if type == "directory" then
+          lib.filesystem.listFilesRecursive (dir + "/${name}")
+        else
+          dir + "/${name}"
+      ) (builtins.readDir dir)
+    );
 
   /**
     Transform a directory tree containing package files suitable for
@@ -373,29 +378,49 @@ in
   */
   packagesFromDirectoryRecursive =
     let
-      inherit (lib) concatMapAttrs id makeScope recurseIntoAttrs removeSuffix;
+      inherit (lib)
+        concatMapAttrs
+        id
+        makeScope
+        recurseIntoAttrs
+        removeSuffix
+        ;
       inherit (lib.path) append;
 
       # Generate an attrset corresponding to a given directory.
       # This function is outside `packagesFromDirectoryRecursive`'s lambda expression,
       #  to prevent accidentally using its parameters.
-      processDir = { callPackage, directory, ... }@args:
-        concatMapAttrs (name: type:
+      processDir =
+        { callPackage, directory, ... }@args:
+        concatMapAttrs (
+          name: type:
           # for each directory entry
-          let path = append directory name; in
-          if type == "directory" then {
-            # recurse into directories
-            "${name}" = packagesFromDirectoryRecursive (args // {
-              directory = path;
-            });
-          } else if type == "regular" && hasSuffix ".nix" name then {
-            # call .nix files
-            "${removeSuffix ".nix" name}" = callPackage path {};
-          } else if type == "regular" then {
-            # ignore non-nix files
-          } else throw ''
-            lib.filesystem.packagesFromDirectoryRecursive: Unsupported file type ${type} at path ${toString path}
-          ''
+          let
+            path = append directory name;
+          in
+          if type == "directory" then
+            {
+              # recurse into directories
+              "${name}" = packagesFromDirectoryRecursive (
+                args
+                // {
+                  directory = path;
+                }
+              );
+            }
+          else if type == "regular" && hasSuffix ".nix" name then
+            {
+              # call .nix files
+              "${removeSuffix ".nix" name}" = callPackage path { };
+            }
+          else if type == "regular" then
+            {
+              # ignore non-nix files
+            }
+          else
+            throw ''
+              lib.filesystem.packagesFromDirectoryRecursive: Unsupported file type ${type} at path ${toString path}
+            ''
         ) (builtins.readDir directory);
     in
     {
@@ -408,20 +433,25 @@ in
     in
     if pathExists defaultPath then
       # if `${directory}/package.nix` exists, call it directly
-      callPackage defaultPath {}
+      callPackage defaultPath { }
     else if args ? newScope then
       # Create a new scope and mark it `recurseForDerivations`.
       # This lets the packages refer to each other.
       # See:
       #  [lib.makeScope](https://nixos.org/manual/nixpkgs/unstable/#function-library-lib.customisation.makeScope) and
       #  [lib.recurseIntoAttrs](https://nixos.org/manual/nixpkgs/unstable/#function-library-lib.customisation.makeScope)
-      recurseIntoAttrs (makeScope newScope (self:
-        # generate the attrset representing the directory, using the new scope's `callPackage` and `newScope`
-        processDir (args // {
-          inherit (self) callPackage newScope;
-        })
-      ))
+      recurseIntoAttrs (
+        makeScope newScope (
+          self:
+          # generate the attrset representing the directory, using the new scope's `callPackage` and `newScope`
+          processDir (
+            args
+            // {
+              inherit (self) callPackage newScope;
+            }
+          )
+        )
+      )
     else
-      processDir args
-  ;
+      processDir args;
 }