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 a08b3a4d19.tar.gz \
      --argstr baseRev b32a094368
    result/bin/apply-formatting $NIXPKGS_PATH

maintainers/scripts/haskell/dependencies.nix

@@ -1,12 +1,17 @@
 # Nix script to calculate the Haskell dependencies of every haskellPackage. Used by ./hydra-report.hs.
 let
-  pkgs = import ../../.. {};
+  pkgs = import ../../.. { };
   inherit (pkgs) lib;
-  getDeps = _: pkg: let
-    pname = pkg.pname or null;
-  in {
-    deps = builtins.filter (x: x != null && x != pname) (map (x: x.pname or null) (pkg.propagatedBuildInputs or []));
-    broken = (pkg.meta.hydraPlatforms or [null]) == [];
-  };
+  getDeps =
+    _: pkg:
+    let
+      pname = pkg.pname or null;
+    in
+    {
+      deps = builtins.filter (x: x != null && x != pname) (
+        map (x: x.pname or null) (pkg.propagatedBuildInputs or [ ])
+      );
+      broken = (pkg.meta.hydraPlatforms or [ null ]) == [ ];
+    };
 in
-  lib.mapAttrs getDeps pkgs.haskellPackages
+lib.mapAttrs getDeps pkgs.haskellPackages

maintainers/scripts/haskell/maintained-broken-pkgs.nix

@@ -1,15 +1,20 @@
 let
   nixpkgs = import ../../..;
-  inherit (nixpkgs {}) haskellPackages lib;
+  inherit (nixpkgs { }) haskellPackages lib;
   maintainedPkgs = lib.filterAttrs (
-    _: v: builtins.length (v.meta.maintainers or []) > 0
+    _: v: builtins.length (v.meta.maintainers or [ ]) > 0
   ) haskellPackages;
   brokenPkgs = lib.filterAttrs (_: v: v.meta.broken) maintainedPkgs;
-  transitiveBrokenPkgs = lib.filterAttrs
-    (_: v: !(builtins.tryEval (v.outPath or null)).success && !v.meta.broken)
-    maintainedPkgs;
-  infoList = pkgs: lib.concatStringsSep "\n" (lib.mapAttrsToList (name: drv: "${name} ${(builtins.elemAt drv.meta.maintainers 0).github}") pkgs);
-in {
+  transitiveBrokenPkgs = lib.filterAttrs (
+    _: v: !(builtins.tryEval (v.outPath or null)).success && !v.meta.broken
+  ) maintainedPkgs;
+  infoList =
+    pkgs:
+    lib.concatStringsSep "\n" (
+      lib.mapAttrsToList (name: drv: "${name} ${(builtins.elemAt drv.meta.maintainers 0).github}") pkgs
+    );
+in
+{
   report = ''
     BROKEN:
     ${infoList brokenPkgs}
@@ -17,6 +22,5 @@ in {
     TRANSITIVE BROKEN:
     ${infoList transitiveBrokenPkgs}
   '';
-  transitiveErrors =
-    builtins.attrValues transitiveBrokenPkgs;
+  transitiveErrors = builtins.attrValues transitiveBrokenPkgs;
 }

maintainers/scripts/haskell/maintainer-handles.nix

@@ -10,12 +10,14 @@
 # This mapping contains all maintainers in ../../mainatainer-list.nix, but it
 # ignores maintainers who don't have a GitHub account or an email address.
 let
-  pkgs = import ../../.. {};
+  pkgs = import ../../.. { };
   maintainers = import ../../maintainer-list.nix;
   inherit (pkgs) lib;
-  mkMailGithubPair = _: maintainer:
+  mkMailGithubPair =
+    _: maintainer:
     if (maintainer ? email) && (maintainer ? github) then
       { "${maintainer.email}" = maintainer.github; }
     else
-      {};
-in lib.zipAttrsWith (_: builtins.head) (lib.mapAttrsToList mkMailGithubPair maintainers)
+      { };
+in
+lib.zipAttrsWith (_: builtins.head) (lib.mapAttrsToList mkMailGithubPair maintainers)

maintainers/scripts/haskell/test-configurations.nix

@@ -1,60 +1,63 @@
-/* Nix expression to test for regressions in the Haskell configuration overlays.
+/*
+  Nix expression to test for regressions in the Haskell configuration overlays.
 
-   test-configurations.nix determines all attributes touched by given Haskell
-   configuration overlays (i. e. pkgs/development/haskell-modules/configuration-*.nix)
-   and builds all derivations (or at least a reasonable subset) affected by
-   these overrides.
+  test-configurations.nix determines all attributes touched by given Haskell
+  configuration overlays (i. e. pkgs/development/haskell-modules/configuration-*.nix)
+  and builds all derivations (or at least a reasonable subset) affected by
+  these overrides.
 
-   By default, it checks `configuration-{common,nix,ghc-8.10.x}.nix`. You can
-   invoke it like this:
+  By default, it checks `configuration-{common,nix,ghc-8.10.x}.nix`. You can
+  invoke it like this:
 
-     nix-build maintainers/scripts/haskell/test-configurations.nix --keep-going
+    nix-build maintainers/scripts/haskell/test-configurations.nix --keep-going
 
-   It is possible to specify other configurations:
+  It is possible to specify other configurations:
 
-     nix-build maintainers/scripts/haskell/test-configurations.nix \
-       --arg files '[ "configuration-ghc-9.0.x.nix" "configuration-ghc-9.2.x.nix" ]' \
-       --keep-going
+    nix-build maintainers/scripts/haskell/test-configurations.nix \
+      --arg files '[ "configuration-ghc-9.0.x.nix" "configuration-ghc-9.2.x.nix" ]' \
+      --keep-going
 
-   You can also just supply a single string:
+  You can also just supply a single string:
 
-     nix-build maintainers/scripts/haskell/test-configurations.nix \
-       --argstr files "configuration-arm.nix" --keep-going
+    nix-build maintainers/scripts/haskell/test-configurations.nix \
+      --argstr files "configuration-arm.nix" --keep-going
 
-   You can even supply full paths which is handy, as it allows for tab-completing
-   the configurations:
+  You can even supply full paths which is handy, as it allows for tab-completing
+  the configurations:
 
-     nix-build maintainers/scripts/haskell/test-configurations.nix \
-       --argstr files pkgs/development/haskell-modules/configuration-arm.nix \
-       --keep-going
+    nix-build maintainers/scripts/haskell/test-configurations.nix \
+      --argstr files pkgs/development/haskell-modules/configuration-arm.nix \
+      --keep-going
 
-   By default, derivation that fail to evaluate are skipped, unless they are
-   “just” marked as broken. You can check for other eval errors like this:
+  By default, derivation that fail to evaluate are skipped, unless they are
+  “just” marked as broken. You can check for other eval errors like this:
 
-     nix-build maintainers/scripts/haskell/test-configurations.nix \
-       --arg skipEvalErrors false --keep-going
+    nix-build maintainers/scripts/haskell/test-configurations.nix \
+      --arg skipEvalErrors false --keep-going
 
-   You can also disable checking broken packages by passing a nixpkgs config:
+  You can also disable checking broken packages by passing a nixpkgs config:
 
-     nix-build maintainers/scripts/haskell/test-configurations.nix \
-       --arg config '{ allowBroken = false; }' --keep-going
+    nix-build maintainers/scripts/haskell/test-configurations.nix \
+      --arg config '{ allowBroken = false; }' --keep-going
 
-   By default the haskell.packages.ghc*Binary sets used for bootstrapping GHC
-   are _not_ tested. You can change this using:
-
-     nix-build maintainers/scripts/haskell/test-configurations.nix \
-       --arg skipBinaryGHCs false --keep-going
+  By default the haskell.packages.ghc*Binary sets used for bootstrapping GHC
+  are _not_ tested. You can change this using:
 
+    nix-build maintainers/scripts/haskell/test-configurations.nix \
+      --arg skipBinaryGHCs false --keep-going
 */
-{ files ? [
+{
+  files ? [
     "configuration-common.nix"
     "configuration-nix.nix"
     "configuration-ghc-8.10.x.nix"
-  ]
-, nixpkgsPath ? ../../..
-, config ? { allowBroken = true; }
-, skipEvalErrors ? true
-, skipBinaryGHCs ? true
+  ],
+  nixpkgsPath ? ../../..,
+  config ? {
+    allowBroken = true;
+  },
+  skipEvalErrors ? true,
+  skipBinaryGHCs ? true,
 }:
 
 let
@@ -62,97 +65,99 @@ let
   inherit (pkgs) lib;
 
   # see usage explanation for the input format `files` allows
-  files' = builtins.map builtins.baseNameOf (
-    if !builtins.isList files then [ files ] else files
-  );
+  files' = builtins.map builtins.baseNameOf (if !builtins.isList files then [ files ] else files);
 
-  packageSetsWithVersionedHead = pkgs.haskell.packages // (
-    let
-      headSet = pkgs.haskell.packages.ghcHEAD;
-      # Determine the next GHC release version following GHC HEAD.
-      # GHC HEAD always has an uneven, tentative version number, e.g. 9.7.
-      # GHC releases always have even numbers, i.e. GHC 9.8 is branched off from
-      # GHC HEAD 9.7. Since we use the to be release number for GHC HEAD's
-      # configuration file, we need to calculate this here.
-      headVersion = lib.pipe headSet.ghc.version [
-        lib.versions.splitVersion
-        (lib.take 2)
-        lib.concatStrings
-        lib.strings.toInt
-        (builtins.add 1)
-        toString
-      ];
-    in
-    {
-      "ghc${headVersion}" = headSet;
-    }
-  );
+  packageSetsWithVersionedHead =
+    pkgs.haskell.packages
+    // (
+      let
+        headSet = pkgs.haskell.packages.ghcHEAD;
+        # Determine the next GHC release version following GHC HEAD.
+        # GHC HEAD always has an uneven, tentative version number, e.g. 9.7.
+        # GHC releases always have even numbers, i.e. GHC 9.8 is branched off from
+        # GHC HEAD 9.7. Since we use the to be release number for GHC HEAD's
+        # configuration file, we need to calculate this here.
+        headVersion = lib.pipe headSet.ghc.version [
+          lib.versions.splitVersion
+          (lib.take 2)
+          lib.concatStrings
+          lib.strings.toInt
+          (builtins.add 1)
+          toString
+        ];
+      in
+      {
+        "ghc${headVersion}" = headSet;
+      }
+    );
 
-  setsForFile = fileName:
+  setsForFile =
+    fileName:
     let
       # extract the unique part of the config's file name
-      configName = builtins.head (
-        builtins.match "configuration-(.+).nix" fileName
-      );
+      configName = builtins.head (builtins.match "configuration-(.+).nix" fileName);
       # match the major and minor version of the GHC the config is intended for, if any
-      configVersion = lib.concatStrings (
-        builtins.match "ghc-([0-9]+).([0-9]+).x" configName
-      );
+      configVersion = lib.concatStrings (builtins.match "ghc-([0-9]+).([0-9]+).x" configName);
       # return all package sets under haskell.packages matching the version components
-      setsForVersion =  builtins.map (name: packageSetsWithVersionedHead.${name}) (
-        builtins.filter (setName:
-          lib.hasPrefix "ghc${configVersion}" setName
-          && (skipBinaryGHCs -> !(lib.hasInfix "Binary" setName))
-        ) (
-          builtins.attrNames packageSetsWithVersionedHead
-        )
+      setsForVersion = builtins.map (name: packageSetsWithVersionedHead.${name}) (
+        builtins.filter (
+          setName:
+          lib.hasPrefix "ghc${configVersion}" setName && (skipBinaryGHCs -> !(lib.hasInfix "Binary" setName))
+        ) (builtins.attrNames packageSetsWithVersionedHead)
       );
 
       defaultSets = [ pkgs.haskellPackages ];
-    in {
+    in
+    {
       # use plain haskellPackages for the version-agnostic files
       # TODO(@sternenseemann): also consider currently selected versioned sets
       "common" = defaultSets;
       "nix" = defaultSets;
       "arm" = defaultSets;
       "darwin" = defaultSets;
-    }.${configName} or setsForVersion;
+    }
+    .${configName} or setsForVersion;
 
   # attribute set that has all the attributes of haskellPackages set to null
   availableHaskellPackages = builtins.listToAttrs (
-    builtins.map (attr: lib.nameValuePair attr null) (
-      builtins.attrNames pkgs.haskellPackages
-    )
+    builtins.map (attr: lib.nameValuePair attr null) (builtins.attrNames pkgs.haskellPackages)
   );
 
   # evaluate a configuration and only return the attributes changed by it,
   # pass availableHaskellPackages as super in case intersectAttrs is used
-  overriddenAttrs = fileName: builtins.attrNames (
-    lib.fix (self:
-      import (nixpkgsPath + "/pkgs/development/haskell-modules/${fileName}") {
-        haskellLib = pkgs.haskell.lib.compose;
-        inherit pkgs;
-      } self availableHaskellPackages
-    )
-  );
+  overriddenAttrs =
+    fileName:
+    builtins.attrNames (
+      lib.fix (
+        self:
+        import (nixpkgsPath + "/pkgs/development/haskell-modules/${fileName}") {
+          haskellLib = pkgs.haskell.lib.compose;
+          inherit pkgs;
+        } self availableHaskellPackages
+      )
+    );
 
   # list of derivations that are affected by overrides in the given configuration
   # overlays. For common, nix, darwin etc. only the derivation from the default
   # package set will be emitted.
-  packages = builtins.filter (v:
-    lib.warnIf (v.meta.broken or false) "${v.pname} is marked as broken" (
-      v != null
-      && (skipEvalErrors -> (builtins.tryEval (v.outPath or v)).success)
-    )
-  ) (
-    lib.concatMap (fileName:
-      let
-        sets = setsForFile fileName;
-        attrs = overriddenAttrs fileName;
-      in
-        lib.concatMap (set: builtins.map (attr: set.${attr}) attrs) sets
-    ) files'
-  );
+  packages =
+    builtins.filter
+      (
+        v:
+        lib.warnIf (v.meta.broken or false) "${v.pname} is marked as broken" (
+          v != null && (skipEvalErrors -> (builtins.tryEval (v.outPath or v)).success)
+        )
+      )
+      (
+        lib.concatMap (
+          fileName:
+          let
+            sets = setsForFile fileName;
+            attrs = overriddenAttrs fileName;
+          in
+          lib.concatMap (set: builtins.map (attr: set.${attr}) attrs) sets
+        ) files'
+      );
 in
 
 packages

maintainers/scripts/haskell/transitive-broken-packages.nix

@@ -1,15 +1,16 @@
 let
   nixpkgs = import ../../..;
-  inherit (nixpkgs {}) pkgs lib;
-  getEvaluating = x:
+  inherit (nixpkgs { }) pkgs lib;
+  getEvaluating =
+    x:
     builtins.attrNames (
       lib.filterAttrs (
         _: v: (builtins.tryEval (v.outPath or null)).success && lib.isDerivation v && !v.meta.broken
       ) x
     );
-  brokenDeps = lib.subtractLists
-    (getEvaluating pkgs.haskellPackages)
-    (getEvaluating (nixpkgs { config.allowBroken = true; }).haskellPackages);
+  brokenDeps = lib.subtractLists (getEvaluating pkgs.haskellPackages) (
+    getEvaluating (nixpkgs { config.allowBroken = true; }).haskellPackages
+  );
 in
 ''
   ${lib.concatMapStringsSep "\n" (x: " - ${x}") brokenDeps}