treewide: format all inactive Nix files

After final improvements to the official formatter implementation,
this commit now performs the first treewide reformat of Nix files using it.
This is part of the implementation of RFC 166.

Only "inactive" files are reformatted, meaning only files that
aren't being touched by any PR with activity in the past 2 months.
This is to avoid conflicts for PRs that might soon be merged.
Later we can do a full treewide reformat to get the rest,
which should not cause as many conflicts.

A CI check has already been running for some time to ensure that new and
already-formatted files are formatted, so the files being reformatted here
should also stay formatted.

This commit was automatically created and can be verified using

    nix-build https://github.com/infinisil/treewide-nixpkgs-reformat-script/archive/a08b3a4d199c6124ac5b36a889d9099b4383463f.tar.gz \
      --argstr baseRev b32a0943687d2a5094a6d92f25a4b6e16a76b5b7
    result/bin/apply-formatting $NIXPKGS_PATH

4 files changed, 190 insertions, 143 deletions

diff --git a/lib/path/default.nix b/lib/path/default.nix
index e6b385c0aee0..e8f0c646c545 100644
--- a/lib/path/default.nix
+++ b/lib/path/default.nix
@@ -1,4 +1,4 @@
-/* Functions for working with path values. */
+# Functions for working with path values.
 # See ./README.md for internal docs
 { lib }:
 let
@@ -41,8 +41,9 @@ let
     ;
 
   # Return the reason why a subpath is invalid, or `null` if it's valid
-  subpathInvalidReason = value:
-    if ! isString value then
+  subpathInvalidReason =
+    value:
+    if !isString value then
       "The given value is of type ${builtins.typeOf value}, but a string was expected"
     else if value == "" then
       "The given string is empty"
@@ -51,11 +52,13 @@ let
     # We don't support ".." components, see ./path.md#parent-directory
     else if match "(.*/)?\\.\\.(/.*)?" value != null then
       "The given string \"${value}\" contains a `..` component, which is not allowed in subpaths"
-    else null;
+    else
+      null;
 
   # Split and normalise a relative path string into its components.
   # Error for ".." components and doesn't include "." components
-  splitRelPath = path:
+  splitRelPath =
+    path:
     let
       # Split the string into its parts using regex for efficiency. This regex
       # matches patterns like "/", "/./", "/././", with arbitrarily many "/"s
@@ -86,26 +89,31 @@ let
       componentCount = partCount - skipEnd - skipStart;
 
     in
-      # Special case of a single "." path component. Such a case leaves a
-      # componentCount of -1 due to the skipStart/skipEnd not verifying that
-      # they don't refer to the same character
-      if path == "." then []
+    # Special case of a single "." path component. Such a case leaves a
+    # componentCount of -1 due to the skipStart/skipEnd not verifying that
+    # they don't refer to the same character
+    if path == "." then
+      [ ]
 
-      # Generate the result list directly. This is more efficient than a
-      # combination of `filter`, `init` and `tail`, because here we don't
-      # allocate any intermediate lists
-      else genList (index:
+    # Generate the result list directly. This is more efficient than a
+    # combination of `filter`, `init` and `tail`, because here we don't
+    # allocate any intermediate lists
+    else
+      genList (
+        index:
         # To get to the element we need to add the number of parts we skip and
         # multiply by two due to the interleaved layout of `parts`
         elemAt parts ((skipStart + index) * 2)
       ) componentCount;
 
   # Join relative path components together
-  joinRelPath = components:
+  joinRelPath =
+    components:
     # Always return relative paths with `./` as a prefix (./path.md#leading-dots-for-relative-paths)
-    "./" +
-    # An empty string is not a valid relative path, so we need to return a `.` when we have no components
-    (if components == [] then "." else concatStringsSep "/" components);
+    "./"
+    +
+      # An empty string is not a valid relative path, so we need to return a `.` when we have no components
+      (if components == [ ] then "." else concatStringsSep "/" components);
 
   # Type: Path -> { root :: Path, components :: [ String ] }
   #
@@ -117,11 +125,18 @@ let
   # because it can distinguish different filesystem roots
   deconstructPath =
     let
-      recurse = components: base:
+      recurse =
+        components: base:
         # If the parent of a path is the path itself, then it's a filesystem root
-        if base == dirOf base then { root = base; inherit components; }
-        else recurse ([ (baseNameOf base) ] ++ components) (dirOf base);
-    in recurse [];
+        if base == dirOf base then
+          {
+            root = base;
+            inherit components;
+          }
+        else
+          recurse ([ (baseNameOf base) ] ++ components) (dirOf base);
+    in
+    recurse [ ];
 
   # The components of the store directory, typically [ "nix" "store" ]
   storeDirComponents = splitRelPath ("./" + storeDir);
@@ -132,7 +147,8 @@ let
   #
   # Whether path components have a store path as a prefix, according to
   # https://nixos.org/manual/nix/stable/store/store-path.html#store-path.
-  componentsHaveStorePathPrefix = components:
+  componentsHaveStorePathPrefix =
+    components:
     # path starts with the store directory (typically /nix/store)
     listHasPrefix storeDirComponents components
     # is not the store directory itself, meaning there's at least one extra component
@@ -145,7 +161,9 @@ let
     # We care more about discerning store path-ness on realistic values. Making it airtight would be fragile and slow.
     && match ".{32}-.+" (elemAt components storeDirLength) != null;
 
-in /* No rec! Add dependencies on this file at the top. */ {
+in
+# No rec! Add dependencies on this file at the top.
+{
 
   /*
     Append a subpath string to a path.
@@ -194,8 +212,8 @@ in /* No rec! Add dependencies on this file at the top. */ {
     path:
     # The subpath string to append
     subpath:
-    assert assertMsg (isPath path) ''
-      lib.path.append: The first argument is of type ${builtins.typeOf path}, but a path was expected'';
+    assert assertMsg (isPath path)
+      ''lib.path.append: The first argument is of type ${builtins.typeOf path}, but a path was expected'';
     assert assertMsg (isValid subpath) ''
       lib.path.append: Second argument is not a valid subpath string:
           ${subpathInvalidReason subpath}'';
@@ -225,25 +243,23 @@ in /* No rec! Add dependencies on this file at the top. */ {
   */
   hasPrefix =
     path1:
-    assert assertMsg
-      (isPath path1)
+    assert assertMsg (isPath path1)
       "lib.path.hasPrefix: First argument is of type ${typeOf path1}, but a path was expected";
     let
       path1Deconstructed = deconstructPath path1;
     in
-      path2:
-      assert assertMsg
-        (isPath path2)
-        "lib.path.hasPrefix: Second argument is of type ${typeOf path2}, but a path was expected";
-      let
-        path2Deconstructed = deconstructPath path2;
-      in
-        assert assertMsg
-        (path1Deconstructed.root == path2Deconstructed.root) ''
-          lib.path.hasPrefix: Filesystem roots must be the same for both paths, but paths with different roots were given:
-              first argument: "${toString path1}" with root "${toString path1Deconstructed.root}"
-              second argument: "${toString path2}" with root "${toString path2Deconstructed.root}"'';
-        take (length path1Deconstructed.components) path2Deconstructed.components == path1Deconstructed.components;
+    path2:
+    assert assertMsg (isPath path2)
+      "lib.path.hasPrefix: Second argument is of type ${typeOf path2}, but a path was expected";
+    let
+      path2Deconstructed = deconstructPath path2;
+    in
+    assert assertMsg (path1Deconstructed.root == path2Deconstructed.root) ''
+      lib.path.hasPrefix: Filesystem roots must be the same for both paths, but paths with different roots were given:
+          first argument: "${toString path1}" with root "${toString path1Deconstructed.root}"
+          second argument: "${toString path2}" with root "${toString path2Deconstructed.root}"'';
+    take (length path1Deconstructed.components) path2Deconstructed.components
+    == path1Deconstructed.components;
 
   /*
     Remove the first path as a component-wise prefix from the second path.
@@ -270,33 +286,29 @@ in /* No rec! Add dependencies on this file at the top. */ {
   */
   removePrefix =
     path1:
-    assert assertMsg
-      (isPath path1)
+    assert assertMsg (isPath path1)
       "lib.path.removePrefix: First argument is of type ${typeOf path1}, but a path was expected.";
     let
       path1Deconstructed = deconstructPath path1;
       path1Length = length path1Deconstructed.components;
     in
-      path2:
-      assert assertMsg
-        (isPath path2)
-        "lib.path.removePrefix: Second argument is of type ${typeOf path2}, but a path was expected.";
-      let
-        path2Deconstructed = deconstructPath path2;
-        success = take path1Length path2Deconstructed.components == path1Deconstructed.components;
-        components =
-          if success then
-            drop path1Length path2Deconstructed.components
-          else
-            throw ''
-              lib.path.removePrefix: The first path argument "${toString path1}" is not a component-wise prefix of the second path argument "${toString path2}".'';
-      in
-        assert assertMsg
-        (path1Deconstructed.root == path2Deconstructed.root) ''
-          lib.path.removePrefix: Filesystem roots must be the same for both paths, but paths with different roots were given:
-              first argument: "${toString path1}" with root "${toString path1Deconstructed.root}"
-              second argument: "${toString path2}" with root "${toString path2Deconstructed.root}"'';
-        joinRelPath components;
+    path2:
+    assert assertMsg (isPath path2)
+      "lib.path.removePrefix: Second argument is of type ${typeOf path2}, but a path was expected.";
+    let
+      path2Deconstructed = deconstructPath path2;
+      success = take path1Length path2Deconstructed.components == path1Deconstructed.components;
+      components =
+        if success then
+          drop path1Length path2Deconstructed.components
+        else
+          throw ''lib.path.removePrefix: The first path argument "${toString path1}" is not a component-wise prefix of the second path argument "${toString path2}".'';
+    in
+    assert assertMsg (path1Deconstructed.root == path2Deconstructed.root) ''
+      lib.path.removePrefix: Filesystem roots must be the same for both paths, but paths with different roots were given:
+          first argument: "${toString path1}" with root "${toString path1Deconstructed.root}"
+          second argument: "${toString path2}" with root "${toString path2Deconstructed.root}"'';
+    joinRelPath components;
 
   /*
     Split the filesystem root from a [path](https://nixos.org/manual/nix/stable/language/values.html#type-path).
@@ -336,12 +348,12 @@ in /* No rec! Add dependencies on this file at the top. */ {
   splitRoot =
     # The path to split the root off of
     path:
-    assert assertMsg
-      (isPath path)
+    assert assertMsg (isPath path)
       "lib.path.splitRoot: Argument is of type ${typeOf path}, but a path was expected";
     let
       deconstructed = deconstructPath path;
-    in {
+    in
+    {
       root = deconstructed.root;
       subpath = joinRelPath deconstructed.components;
     };
@@ -387,12 +399,12 @@ in /* No rec! Add dependencies on this file at the top. */ {
       hasStorePathPrefix /nix/store/nvl9ic0pj1fpyln3zaqrf4cclbqdfn1j-foo.drv
       => true
   */
-  hasStorePathPrefix = path:
+  hasStorePathPrefix =
+    path:
     let
       deconstructed = deconstructPath path;
     in
-    assert assertMsg
-      (isPath path)
+    assert assertMsg (isPath path)
       "lib.path.hasStorePathPrefix: Argument is of type ${typeOf path}, but a path was expected";
     assert assertMsg
       # This function likely breaks or needs adjustment if used with other filesystem roots, if they ever get implemented.
@@ -446,9 +458,7 @@ in /* No rec! Add dependencies on this file at the top. */ {
   */
   subpath.isValid =
     # The value to check
-    value:
-    subpathInvalidReason value == null;
-
+    value: subpathInvalidReason value == null;
 
   /*
     Join subpath strings together using `/`, returning a normalised subpath string.
@@ -511,18 +521,20 @@ in /* No rec! Add dependencies on this file at the top. */ {
     # The list of subpaths to join together
     subpaths:
     # Fast in case all paths are valid
-    if all isValid subpaths
-    then joinRelPath (concatMap splitRelPath subpaths)
+    if all isValid subpaths then
+      joinRelPath (concatMap splitRelPath subpaths)
     else
       # Otherwise we take our time to gather more info for a better error message
       # Strictly go through each path, throwing on the first invalid one
       # Tracks the list index in the fold accumulator
-      foldl' (i: path:
-        if isValid path
-        then i + 1
-        else throw ''
-          lib.path.subpath.join: Element at index ${toString i} is not a valid subpath string:
-              ${subpathInvalidReason path}''
+      foldl' (
+        i: path:
+        if isValid path then
+          i + 1
+        else
+          throw ''
+            lib.path.subpath.join: Element at index ${toString i} is not a valid subpath string:
+                ${subpathInvalidReason path}''
       ) 0 subpaths;
 
   /*
diff --git a/lib/path/tests/default.nix b/lib/path/tests/default.nix
index 93aea798acca..2ea43e04c3b7 100644
--- a/lib/path/tests/default.nix
+++ b/lib/path/tests/default.nix
@@ -2,8 +2,8 @@
   nixpkgs ? ../../..,
   system ? builtins.currentSystem,
   pkgs ? import nixpkgs {
-    config = {};
-    overlays = [];
+    config = { };
+    overlays = [ ];
     inherit system;
   },
   nixVersions ? import ../../tests/nix-for-tests.nix { inherit pkgs; },
@@ -12,34 +12,38 @@
   seed ? null,
 }:
 
-pkgs.runCommand "lib-path-tests" {
-  nativeBuildInputs = [
-    nixVersions.stable
-  ] ++ (with pkgs; [
-    jq
-    bc
-  ]);
-} ''
-  # Needed to make Nix evaluation work
-  export TEST_ROOT=$(pwd)/test-tmp
-  export NIX_BUILD_HOOK=
-  export NIX_CONF_DIR=$TEST_ROOT/etc
-  export NIX_LOCALSTATE_DIR=$TEST_ROOT/var
-  export NIX_LOG_DIR=$TEST_ROOT/var/log/nix
-  export NIX_STATE_DIR=$TEST_ROOT/var/nix
-  export NIX_STORE_DIR=$TEST_ROOT/store
-  export PAGER=cat
+pkgs.runCommand "lib-path-tests"
+  {
+    nativeBuildInputs =
+      [
+        nixVersions.stable
+      ]
+      ++ (with pkgs; [
+        jq
+        bc
+      ]);
+  }
+  ''
+    # Needed to make Nix evaluation work
+    export TEST_ROOT=$(pwd)/test-tmp
+    export NIX_BUILD_HOOK=
+    export NIX_CONF_DIR=$TEST_ROOT/etc
+    export NIX_LOCALSTATE_DIR=$TEST_ROOT/var
+    export NIX_LOG_DIR=$TEST_ROOT/var/log/nix
+    export NIX_STATE_DIR=$TEST_ROOT/var/nix
+    export NIX_STORE_DIR=$TEST_ROOT/store
+    export PAGER=cat
 
-  cp -r ${libpath} lib
-  export TEST_LIB=$PWD/lib
+    cp -r ${libpath} lib
+    export TEST_LIB=$PWD/lib
 
-  echo "Running unit tests lib/path/tests/unit.nix"
-  nix-instantiate --eval --show-trace \
-    --argstr libpath "$TEST_LIB" \
-    lib/path/tests/unit.nix
+    echo "Running unit tests lib/path/tests/unit.nix"
+    nix-instantiate --eval --show-trace \
+      --argstr libpath "$TEST_LIB" \
+      lib/path/tests/unit.nix
 
-  echo "Running property tests lib/path/tests/prop.sh"
-  bash lib/path/tests/prop.sh ${toString seed}
+    echo "Running property tests lib/path/tests/prop.sh"
+    bash lib/path/tests/prop.sh ${toString seed}
 
-  touch $out
-''
+    touch $out
+  ''
diff --git a/lib/path/tests/prop.nix b/lib/path/tests/prop.nix
index 67e5c1e9d61c..b4fa355e9525 100644
--- a/lib/path/tests/prop.nix
+++ b/lib/path/tests/prop.nix
@@ -16,14 +16,15 @@ let
   lib = import libpath;
 
   # read each file into a string
-  strings = map (name:
-    builtins.readFile (dir + "/${name}")
-  ) (builtins.attrNames (builtins.readDir dir));
+  strings = map (name: builtins.readFile (dir + "/${name}")) (
+    builtins.attrNames (builtins.readDir dir)
+  );
 
   inherit (lib.path.subpath) normalise isValid;
   inherit (lib.asserts) assertMsg;
 
-  normaliseAndCheck = str:
+  normaliseAndCheck =
+    str:
     let
       originalValid = isValid str;
 
@@ -33,28 +34,27 @@ let
       absConcatOrig = /. + ("/" + str);
       absConcatNormalised = /. + ("/" + tryOnce.value);
     in
-      # Check the lib.path.subpath.normalise property to only error on invalid subpaths
-      assert assertMsg
-        (originalValid -> tryOnce.success)
-        "Even though string \"${str}\" is valid as a subpath, the normalisation for it failed";
-      assert assertMsg
-        (! originalValid -> ! tryOnce.success)
-        "Even though string \"${str}\" is invalid as a subpath, the normalisation for it succeeded";
+    # Check the lib.path.subpath.normalise property to only error on invalid subpaths
+    assert assertMsg (
+      originalValid -> tryOnce.success
+    ) "Even though string \"${str}\" is valid as a subpath, the normalisation for it failed";
+    assert assertMsg (
+      !originalValid -> !tryOnce.success
+    ) "Even though string \"${str}\" is invalid as a subpath, the normalisation for it succeeded";
 
-      # Check normalisation idempotency
-      assert assertMsg
-        (originalValid -> tryTwice.success)
-        "For valid subpath \"${str}\", the normalisation \"${tryOnce.value}\" was not a valid subpath";
-      assert assertMsg
-        (originalValid -> tryOnce.value == tryTwice.value)
-        "For valid subpath \"${str}\", normalising it once gives \"${tryOnce.value}\" but normalising it twice gives a different result: \"${tryTwice.value}\"";
+    # Check normalisation idempotency
+    assert assertMsg (
+      originalValid -> tryTwice.success
+    ) "For valid subpath \"${str}\", the normalisation \"${tryOnce.value}\" was not a valid subpath";
+    assert assertMsg (originalValid -> tryOnce.value == tryTwice.value)
+      "For valid subpath \"${str}\", normalising it once gives \"${tryOnce.value}\" but normalising it twice gives a different result: \"${tryTwice.value}\"";
 
-      # Check that normalisation doesn't change a string when appended to an absolute Nix path value
-      assert assertMsg
-        (originalValid -> absConcatOrig == absConcatNormalised)
-        "For valid subpath \"${str}\", appending to an absolute Nix path value gives \"${absConcatOrig}\", but appending the normalised result \"${tryOnce.value}\" gives a different value \"${absConcatNormalised}\"";
+    # Check that normalisation doesn't change a string when appended to an absolute Nix path value
+    assert assertMsg (originalValid -> absConcatOrig == absConcatNormalised)
+      "For valid subpath \"${str}\", appending to an absolute Nix path value gives \"${absConcatOrig}\", but appending the normalised result \"${tryOnce.value}\" gives a different value \"${absConcatNormalised}\"";
 
-      # Return an empty string when failed
-      if tryOnce.success then tryOnce.value else "";
+    # Return an empty string when failed
+    if tryOnce.success then tryOnce.value else "";
 
-in lib.genAttrs strings normaliseAndCheck
+in
+lib.genAttrs strings normaliseAndCheck
diff --git a/lib/path/tests/unit.nix b/lib/path/tests/unit.nix
index 9b0a0b2714aa..903e8ff0acff 100644
--- a/lib/path/tests/unit.nix
+++ b/lib/path/tests/unit.nix
@@ -3,7 +3,14 @@
 { libpath }:
 let
   lib = import libpath;
-  inherit (lib.path) hasPrefix removePrefix append splitRoot hasStorePathPrefix subpath;
+  inherit (lib.path)
+    hasPrefix
+    removePrefix
+    append
+    splitRoot
+    hasStorePathPrefix
+    subpath
+    ;
 
   # This is not allowed generally, but we're in the tests here, so we'll allow ourselves.
   storeDirPath = /. + builtins.storeDir;
@@ -79,15 +86,24 @@ let
 
     testSplitRootExample1 = {
       expr = splitRoot /foo/bar;
-      expected = { root = /.; subpath = "./foo/bar"; };
+      expected = {
+        root = /.;
+        subpath = "./foo/bar";
+      };
     };
     testSplitRootExample2 = {
       expr = splitRoot /.;
-      expected = { root = /.; subpath = "./."; };
+      expected = {
+        root = /.;
+        subpath = "./.";
+      };
     };
     testSplitRootExample3 = {
       expr = splitRoot /foo/../bar;
-      expected = { root = /.; subpath = "./bar"; };
+      expected = {
+        root = /.;
+        subpath = "./bar";
+      };
     };
     testSplitRootExample4 = {
       expr = (builtins.tryEval (splitRoot "/foo/bar")).success;
@@ -111,7 +127,9 @@ let
       expected = false;
     };
     testHasStorePathPrefixExample5 = {
-      expr = hasStorePathPrefix (storeDirPath + "/.links/10gg8k3rmbw8p7gszarbk7qyd9jwxhcfq9i6s5i0qikx8alkk4hq");
+      expr = hasStorePathPrefix (
+        storeDirPath + "/.links/10gg8k3rmbw8p7gszarbk7qyd9jwxhcfq9i6s5i0qikx8alkk4hq"
+      );
       expected = false;
     };
     testHasStorePathPrefixExample6 = {
@@ -188,11 +206,18 @@ let
 
     # Test examples from the lib.path.subpath.join documentation
     testSubpathJoinExample1 = {
-      expr = subpath.join [ "foo" "bar/baz" ];
+      expr = subpath.join [
+        "foo"
+        "bar/baz"
+      ];
       expected = "./foo/bar/baz";
     };
     testSubpathJoinExample2 = {
-      expr = subpath.join [ "./foo" "." "bar//./baz/" ];
+      expr = subpath.join [
+        "./foo"
+        "."
+        "bar//./baz/"
+      ];
       expected = "./foo/bar/baz";
     };
     testSubpathJoinExample3 = {
@@ -273,7 +298,11 @@ let
     };
     testSubpathComponentsExample2 = {
       expr = subpath.components "./foo//bar/./baz/";
-      expected = [ "foo" "bar" "baz" ];
+      expected = [
+        "foo"
+        "bar"
+        "baz"
+      ];
     };
     testSubpathComponentsExample3 = {
       expr = (builtins.tryEval (subpath.components "/foo")).success;
@@ -281,5 +310,7 @@ let
     };
   };
 in
-  if cases == [] then "Unit tests successful"
-  else throw "Path unit tests failed: ${lib.generators.toPretty {} cases}"
+if cases == [ ] then
+  "Unit tests successful"
+else
+  throw "Path unit tests failed: ${lib.generators.toPretty { } cases}"