Format Nix code with nixfmt

Change-Id: I61efeb666ff7481c05fcb247168290e86a250151

default.nix

@@ -1,10 +1,9 @@
-(import
+(import (
-  (
+  let
-    let lock = builtins.fromJSON (builtins.readFile ./flake.lock); in
+    lock = builtins.fromJSON (builtins.readFile ./flake.lock);
+  in
   fetchTarball {
     url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
     sha256 = lock.nodes.flake-compat.locked.narHash;
   }
-  )
+) { src = ./.; }).defaultNix
-  { src = ./.; }
-).defaultNix

doc/manual/generate-builtin-constants.nix

@@ -5,7 +5,13 @@ in
 
 builtinsInfo:
 let
-  showBuiltin = name: { doc, type, impure-only }:
+  showBuiltin =
+    name:
+    {
+      doc,
+      type,
+      impure-only,
+    }:
     let
       type' = optionalString (type != null) " (${type})";
 

doc/manual/generate-builtins.nix

@@ -5,7 +5,14 @@ in
 
 builtinsInfo:
 let
-  showBuiltin = name: { doc, args, arity, experimental-feature }:
+  showBuiltin =
+    name:
+    {
+      doc,
+      args,
+      arity,
+      experimental-feature,
+    }:
     let
       experimentalNotice = optionalString (experimental-feature != null) ''
         This function is only available if the [${experimental-feature}](@docroot@/contributing/experimental-features.md#xp-feature-${experimental-feature}) experimental feature is enabled.

doc/manual/generate-manpage.nix

@@ -1,8 +1,26 @@
 let
   inherit (builtins)
-    attrNames attrValues fromJSON listToAttrs mapAttrs
+    attrNames
-    concatStringsSep concatMap length lessThan replaceStrings sort;
+    attrValues
-  inherit (import ./utils.nix) concatStrings optionalString filterAttrs trim squash unique showSettings;
+    fromJSON
+    listToAttrs
+    mapAttrs
+    concatStringsSep
+    concatMap
+    length
+    lessThan
+    replaceStrings
+    sort
+    ;
+  inherit (import ./utils.nix)
+    concatStrings
+    optionalString
+    filterAttrs
+    trim
+    squash
+    unique
+    showSettings
+    ;
 in
 
 inlineHTML: commandDump:
@@ -11,7 +29,13 @@ let
 
   commandInfo = fromJSON commandDump;
 
-  showCommand = { command, details, filename, toplevel }:
+  showCommand =
+    {
+      command,
+      details,
+      filename,
+      toplevel,
+    }:
     let
 
       result = ''
@@ -35,26 +59,27 @@ let
         ${maybeOptions}
       '';
 
-      showSynopsis = command: args:
+      showSynopsis =
+        command: args:
         let
-          showArgument = arg: "*${arg.label}*" + optionalString (! arg ? arity) "...";
+          showArgument = arg: "*${arg.label}*" + optionalString (!arg ? arity) "...";
           arguments = concatStringsSep " " (map showArgument args);
-        in ''
+        in
+        ''
           `${command}` [*option*...] ${arguments}
         '';
 
-      maybeSubcommands = optionalString (details ? commands && details.commands != {})
+      maybeSubcommands = optionalString (details ? commands && details.commands != { }) ''
-         ''
         where *subcommand* is one of the following:
 
         ${subcommands}
       '';
 
-      subcommands = if length categories > 1
+      subcommands = if length categories > 1 then listCategories else listSubcommands details.commands;
-        then listCategories
-        else listSubcommands details.commands;
 
-      categories = sort (x: y: x.id < y.id) (unique (map (cmd: cmd.category) (attrValues details.commands)));
+      categories = sort (x: y: x.id < y.id) (
+        unique (map (cmd: cmd.category) (attrValues details.commands))
+      );
 
       listCategories = concatStrings (map showCategory categories);
 
@@ -71,11 +96,11 @@ let
       '';
 
       # TODO: move this confusing special case out of here when implementing #8496
-      maybeStoreDocs = optionalString
+      maybeStoreDocs = optionalString (details ? doc) (
-        (details ? doc)
+        replaceStrings [ "@stores@" ] [ storeDocs ] details.doc
-        (replaceStrings ["@stores@"] [storeDocs] details.doc);
+      );
 
-      maybeOptions = optionalString (details.flags != {}) ''
+      maybeOptions = optionalString (details.flags != { }) ''
         # Options
 
         ${showOptions details.flags toplevel.flags}
@@ -85,7 +110,8 @@ let
         > See [`man nix.conf`](@docroot@/command-ref/conf-file.md#command-line-flags) for overriding configuration settings with command line flags.
       '';
 
-      showOptions = options: commonOptions:
+      showOptions =
+        options: commonOptions:
         let
           allOptions = options // commonOptions;
           showCategory = cat: ''
@@ -94,42 +120,60 @@ let
             ${listOptions (filterAttrs (n: v: v.category == cat) allOptions)}
           '';
           listOptions = opts: concatStringsSep "\n" (attrValues (mapAttrs showOption opts));
-          showOption = name: option:
+          showOption =
+            name: option:
             let
               result = trim ''
                 - ${item}
                   ${option.description}
               '';
-              item = if inlineHTML
+              item =
-                then ''<span id="opt-${name}">[`--${name}`](#opt-${name})</span> ${shortName} ${labels}''
+                if inlineHTML then
-                else "`--${name}` ${shortName} ${labels}";
+                  ''<span id="opt-${name}">[`--${name}`](#opt-${name})</span> ${shortName} ${labels}''
-              shortName = optionalString
+                else
-                (option ? shortName)
+                  "`--${name}` ${shortName} ${labels}";
-                ("/ `-${option.shortName}`");
+              shortName = optionalString (option ? shortName) ("/ `-${option.shortName}`");
-              labels = optionalString
+              labels = optionalString (option ? labels) (concatStringsSep " " (map (s: "*${s}*") option.labels));
-                (option ? labels)
+            in
-                (concatStringsSep " " (map (s: "*${s}*") option.labels));
+            result;
-            in result;
           categories = sort lessThan (unique (map (cmd: cmd.category) (attrValues allOptions)));
-        in concatStrings (map showCategory categories);
+        in
-    in squash result;
+        concatStrings (map showCategory categories);
+    in
+    squash result;
 
   appendName = filename: name: (if filename == "nix" then "nix3" else filename) + "-" + name;
 
-  processCommand = { command, details, filename, toplevel }:
+  processCommand =
+    {
+      command,
+      details,
+      filename,
+      toplevel,
+    }:
     let
       cmd = {
         inherit command;
         name = filename + ".md";
-        value = showCommand { inherit command details filename toplevel; };
+        value = showCommand {
+          inherit
+            command
+            details
+            filename
+            toplevel
+            ;
         };
-      subcommand = subCmd: processCommand {
+      };
+      subcommand =
+        subCmd:
+        processCommand {
           command = command + " " + subCmd;
           details = details.commands.${subCmd};
           filename = appendName filename subCmd;
           inherit toplevel;
         };
-    in [ cmd ] ++ concatMap subcommand (attrNames details.commands or {});
+    in
+    [ cmd ] ++ concatMap subcommand (attrNames details.commands or { });
 
   manpages = processCommand {
     command = "nix";
@@ -138,14 +182,21 @@ let
     toplevel = commandInfo.args;
   };
 
-  tableOfContents = let
+  tableOfContents =
-    showEntry = page:
+    let
-      "    - [${page.command}](command-ref/new-cli/${page.name})";
+      showEntry = page: "    - [${page.command}](command-ref/new-cli/${page.name})";
-    in concatStringsSep "\n" (map showEntry manpages) + "\n";
+    in
+    concatStringsSep "\n" (map showEntry manpages) + "\n";
 
   storeDocs =
     let
-      showStore = name: { settings, doc, experimentalFeature }:
+      showStore =
+        name:
+        {
+          settings,
+          doc,
+          experimentalFeature,
+        }:
         let
           experimentalFeatureNote = optionalString (experimentalFeature != null) ''
             > **Warning**
@@ -161,7 +212,8 @@ let
             extra-experimental-features = ${experimentalFeature}
             ```
           '';
-        in ''
+        in
+        ''
           ## ${name}
 
           ${doc}
@@ -172,6 +224,7 @@ let
 
           ${showSettings { inherit inlineHTML; } settings}
         '';
-    in concatStrings (attrValues (mapAttrs showStore commandInfo.stores));
+    in
-
+    concatStrings (attrValues (mapAttrs showStore commandInfo.stores));
-in (listToAttrs manpages) // { "SUMMARY.md" = tableOfContents; }
+in
+(listToAttrs manpages) // { "SUMMARY.md" = tableOfContents; }

doc/manual/generate-xp-features-shortlist.nix

@@ -2,8 +2,8 @@ with builtins;
 with import ./utils.nix;
 
 let
-  showExperimentalFeature = name: doc:
+  showExperimentalFeature = name: doc: ''
-    ''
     - [`${name}`](@docroot@/contributing/experimental-features.md#xp-feature-${name})
   '';
-in xps: indent "  " (concatStrings (attrValues (mapAttrs showExperimentalFeature xps)))
+in
+xps: indent "  " (concatStrings (attrValues (mapAttrs showExperimentalFeature xps)))

doc/manual/generate-xp-features.nix

@@ -2,10 +2,12 @@ with builtins;
 with import ./utils.nix;
 
 let
-  showExperimentalFeature = name: doc:
+  showExperimentalFeature =
+    name: doc:
     squash ''
       ## [`${name}`]{#xp-feature-${name}}
 
       ${doc}
     '';
-in xps: (concatStringsSep "\n" (attrValues (mapAttrs showExperimentalFeature xps)))
+in
+xps: (concatStringsSep "\n" (attrValues (mapAttrs showExperimentalFeature xps)))

doc/manual/utils.nix

@@ -5,10 +5,15 @@ rec {
 
   concatStrings = concatStringsSep "";
 
-  attrsToList = a:
+  attrsToList =
-    map (name: { inherit name; value = a.${name}; }) (builtins.attrNames a);
+    a:
+    map (name: {
+      inherit name;
+      value = a.${name};
+    }) (builtins.attrNames a);
 
-  replaceStringsRec = from: to: string:
+  replaceStringsRec =
+    from: to: string:
     # recursively replace occurrences of `from` with `to` within `string`
     # example:
     #     replaceStringRec "--" "-" "hello-----world"
@@ -20,10 +25,12 @@ rec {
 
   squash = replaceStringsRec "\n\n\n" "\n\n";
 
-  trim = string:
+  trim =
+    string:
     # trim trailing spaces and squash non-leading spaces
     let
-      trimLine = line:
+      trimLine =
+        line:
         let
           # separate leading spaces from the rest
           parts = split "(^ *)" line;
@@ -31,25 +38,46 @@ rec {
           rest = elemAt parts 2;
           # drop trailing spaces
           body = head (split " *$" rest);
-        in spaces + replaceStringsRec "  " " " body;
+        in
-    in concatStringsSep "\n" (map trimLine (splitLines string));
+        spaces + replaceStringsRec "  " " " body;
+    in
+    concatStringsSep "\n" (map trimLine (splitLines string));
 
   # FIXME: O(n^2)
-  unique = foldl' (acc: e: if elem e acc then acc else acc ++ [ e ]) [];
+  unique = foldl' (acc: e: if elem e acc then acc else acc ++ [ e ]) [ ];
 
   nameValuePair = name: value: { inherit name value; };
 
-  filterAttrs = pred: set:
+  filterAttrs =
-    listToAttrs (concatMap (name: let v = set.${name}; in if pred name v then [(nameValuePair name v)] else []) (attrNames set));
+    pred: set:
+    listToAttrs (
+      concatMap (
+        name:
+        let
+          v = set.${name};
+        in
+        if pred name v then [ (nameValuePair name v) ] else [ ]
+      ) (attrNames set)
+    );
 
   optionalString = cond: string: if cond then string else "";
 
-  showSetting = { inlineHTML }: name: { description, documentDefault, defaultValue, aliases, value, experimentalFeature }:
+  showSetting =
+    { inlineHTML }:
+    name:
+    {
+      description,
+      documentDefault,
+      defaultValue,
+      aliases,
+      value,
+      experimentalFeature,
+    }:
     let
       result = squash ''
-          - ${if inlineHTML
+        - ${
-              then ''<span id="conf-${name}">[`${name}`](#conf-${name})</span>''
+          if inlineHTML then ''<span id="conf-${name}">[`${name}`](#conf-${name})</span>'' else ''`${name}`''
-              else ''`${name}`''}
+        }
 
         ${indent "  " body}
       '';
@@ -81,26 +109,31 @@ rec {
         ${showAliases aliases}
       '';
 
-      showDefault = documentDefault: defaultValue:
+      showDefault =
+        documentDefault: defaultValue:
         if documentDefault then
           # a StringMap value type is specified as a string, but
           # this shows the value type. The empty stringmap is `null` in
           # JSON, but that converts to `{ }` here.
-          if defaultValue == "" || defaultValue == [] || isAttrs defaultValue
+          if defaultValue == "" || defaultValue == [ ] || isAttrs defaultValue then
-            then "*empty*"
+            "*empty*"
           else if isBool defaultValue then
             if defaultValue then "`true`" else "`false`"
-            else "`${toString defaultValue}`"
+          else
-        else "*machine-specific*";
+            "`${toString defaultValue}`"
+        else
+          "*machine-specific*";
 
-      showAliases = aliases:
+      showAliases =
-          optionalString (aliases != [])
+        aliases:
+        optionalString (aliases != [ ])
           "**Deprecated alias:** ${(concatStringsSep ", " (map (s: "`${s}`") aliases))}";
+    in
+    result;
 
-    in result;
+  indent =
+    prefix: s: concatStringsSep "\n" (map (x: if x == "" then x else "${prefix}${x}") (splitLines s));
 
-  indent = prefix: s:
+  showSettings =
-    concatStringsSep "\n" (map (x: if x == "" then x else "${prefix}${x}") (splitLines s));
+    args: settingsInfo: concatStrings (attrValues (mapAttrs (showSetting args) settingsInfo));
-
-  showSettings = args: settingsInfo: concatStrings (attrValues (mapAttrs (showSetting args) settingsInfo));
 }

docker.nix

@@ -1,17 +1,20 @@
-{ pkgs ? import <nixpkgs> { }
+{
-, lib ? pkgs.lib
+  pkgs ? import <nixpkgs> { },
-, name ? "nix"
+  lib ? pkgs.lib,
-, tag ? "latest"
+  name ? "nix",
-, bundleNixpkgs ? true
+  tag ? "latest",
-, channelName ? "nixpkgs"
+  bundleNixpkgs ? true,
-, channelURL ? "https://nixos.org/channels/nixpkgs-unstable"
+  channelName ? "nixpkgs",
-, extraPkgs ? []
+  channelURL ? "https://nixos.org/channels/nixpkgs-unstable",
-, maxLayers ? 100
+  extraPkgs ? [ ],
-, nixConf ? {}
+  maxLayers ? 100,
-, flake-registry ? null
+  nixConf ? { },
+  flake-registry ? null,
 }:
 let
-  defaultPkgs = with pkgs; [
+  defaultPkgs =
+    with pkgs;
+    [
       nix
       bashInteractive
       coreutils-full
@@ -28,9 +31,11 @@ let
       iana-etc
       git
       openssh
-  ] ++ extraPkgs;
+    ]
+    ++ extraPkgs;
 
-  users = {
+  users =
+    {
 
       root = {
         uid = 0;
@@ -49,11 +54,9 @@ let
         groups = [ "nobody" ];
         description = "Unprivileged account (don't use!)";
       };
-
+    }
-  } // lib.listToAttrs (
+    // lib.listToAttrs (
-    map
+      map (n: {
-      (
-        n: {
         name = "nixbld${toString n}";
         value = {
           uid = 30000 + n;
@@ -61,9 +64,7 @@ let
           groups = [ "nixbld" ];
           description = "Nix build user ${toString n}";
         };
-        }
+      }) (lib.lists.range 1 32)
-      )
-      (lib.lists.range 1 32)
     );
 
   groups = {
@@ -74,24 +75,20 @@ let
 
   userToPasswd = (
     k:
-    { uid
+    {
-    , gid ? 65534
+      uid,
-    , home ? "/var/empty"
+      gid ? 65534,
-    , description ? ""
+      home ? "/var/empty",
-    , shell ? "/bin/false"
+      description ? "",
-    , groups ? [ ]
+      shell ? "/bin/false",
-    }: "${k}:x:${toString uid}:${toString gid}:${description}:${home}:${shell}"
+      groups ? [ ],
-  );
+    }:
-  passwdContents = (
+    "${k}:x:${toString uid}:${toString gid}:${description}:${home}:${shell}"
-    lib.concatStringsSep "\n"
-      (lib.attrValues (lib.mapAttrs userToPasswd users))
   );
+  passwdContents = (lib.concatStringsSep "\n" (lib.attrValues (lib.mapAttrs userToPasswd users)));
 
   userToShadow = k: { ... }: "${k}:!:1::::::";
-  shadowContents = (
+  shadowContents = (lib.concatStringsSep "\n" (lib.attrValues (lib.mapAttrs userToShadow users)));
-    lib.concatStringsSep "\n"
-      (lib.attrValues (lib.mapAttrs userToShadow users))
-  );
 
   # Map groups to members
   # {
@@ -101,42 +98,28 @@ let
     let
       # Create a flat list of user/group mappings
       mappings = (
-        builtins.foldl'
+        builtins.foldl' (
-          (
           acc: user:
           let
             groups = users.${user}.groups or [ ];
           in
-              acc ++ map
+          acc ++ map (group: { inherit user group; }) groups
-                (group: {
+        ) [ ] (lib.attrNames users)
-                  inherit user group;
-                })
-                groups
-          )
-          [ ]
-          (lib.attrNames users)
       );
     in
-    (
+    (builtins.foldl' (
-      builtins.foldl'
+      acc: v: acc // { ${v.group} = acc.${v.group} or [ ] ++ [ v.user ]; }
-        (
+    ) { } mappings)
-          acc: v: acc // {
-            ${v.group} = acc.${v.group} or [ ] ++ [ v.user ];
-          }
-        )
-        { }
-        mappings)
   );
 
-  groupToGroup = k: { gid }:
+  groupToGroup =
+    k:
+    { gid }:
     let
       members = groupMemberMap.${k} or [ ];
     in
     "${k}:x:${toString gid}:${lib.concatStringsSep "," members}";
-  groupContents = (
+  groupContents = (lib.concatStringsSep "\n" (lib.attrValues (lib.mapAttrs groupToGroup groups)));
-    lib.concatStringsSep "\n"
-      (lib.attrValues (lib.mapAttrs groupToGroup groups))
-  );
 
   defaultNixConf = {
     sandbox = "false";
@@ -144,11 +127,17 @@ let
     trusted-public-keys = [ "cache.nixos.org-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=" ];
   };
 
-  nixConfContents = (lib.concatStringsSep "\n" (lib.mapAttrsFlatten (n: v:
+  nixConfContents =
+    (lib.concatStringsSep "\n" (
+      lib.mapAttrsFlatten (
+        n: v:
         let
           vStr = if builtins.isList v then lib.concatStringsSep " " v else v;
         in
-      "${n} = ${vStr}") (defaultNixConf // nixConf))) + "\n";
+        "${n} = ${vStr}"
+      ) (defaultNixConf // nixConf)
+    ))
+    + "\n";
 
   baseSystem =
     let
@@ -167,13 +156,21 @@ let
       manifest = pkgs.buildPackages.runCommand "manifest.nix" { } ''
         cat > $out <<EOF
         [
-        ${lib.concatStringsSep "\n" (builtins.map (drv: let
+        ${lib.concatStringsSep "\n" (
+          builtins.map (
+            drv:
+            let
               outputs = drv.outputsToInstall or [ "out" ];
-        in ''
+            in
+            ''
               {
-            ${lib.concatStringsSep "\n" (builtins.map (output: ''
+                ${
+                  lib.concatStringsSep "\n" (
+                    builtins.map (output: ''
                       ${output} = { outPath = "${lib.getOutput output drv}"; };
-            '') outputs)}
+                    '') outputs
+                  )
+                }
                 outputs = [ ${lib.concatStringsSep " " (builtins.map (x: "\"${x}\"") outputs)} ];
                 name = "${drv.name}";
                 outPath = "${drv}";
@@ -181,7 +178,9 @@ let
                 type = "derivation";
                 meta = { };
               }
-        '') defaultPkgs)}
+            ''
+          ) defaultPkgs
+        )}
         ]
         EOF
       '';
@@ -190,7 +189,8 @@ let
         cp -a ${rootEnv}/* $out/
         ln -s ${manifest} $out/manifest.nix
       '';
-      flake-registry-path = if (flake-registry == null) then
+      flake-registry-path =
+        if (flake-registry == null) then
           null
         else if (builtins.readFileType (toString flake-registry)) == "directory" then
           "${flake-registry}/flake-registry.json"
@@ -199,7 +199,12 @@ let
     in
     pkgs.runCommand "base-system"
       {
-        inherit passwdContents groupContents shadowContents nixConfContents;
+        inherit
+          passwdContents
+          groupContents
+          shadowContents
+          nixConfContents
+          ;
         passAsFile = [
           "passwdContents"
           "groupContents"
@@ -208,7 +213,9 @@ let
         ];
         allowSubstitutes = false;
         preferLocalBuild = true;
-      } (''
+      }
+      (
+        ''
           env
           set -x
           mkdir -p $out/etc
@@ -255,7 +262,8 @@ let
           ln -s ${pkgs.coreutils}/bin/env $out/usr/bin/env
           ln -s ${pkgs.bashInteractive}/bin/bash $out/bin/sh
 
-    '' + (lib.optionalString (flake-registry-path != null) ''
+        ''
+        + (lib.optionalString (flake-registry-path != null) ''
           nixCacheDir="/root/.cache/nix"
           mkdir -p $out$nixCacheDir
           globalFlakeRegistryPath="$nixCacheDir/flake-registry.json"
@@ -263,8 +271,8 @@ let
           mkdir -p $out/nix/var/nix/gcroots/auto
           rootName=$(${pkgs.nix}/bin/nix --extra-experimental-features nix-command hash file --type sha1 --base32 <(echo -n $globalFlakeRegistryPath))
           ln -s $globalFlakeRegistryPath $out/nix/var/nix/gcroots/auto/$rootName
-    ''));
+        '')
-
+      );
 in
 pkgs.dockerTools.buildLayeredImageWithNixDb {
 
@@ -285,20 +293,23 @@ pkgs.dockerTools.buildLayeredImageWithNixDb {
     Cmd = [ "/root/.nix-profile/bin/bash" ];
     Env = [
       "USER=root"
-      "PATH=${lib.concatStringsSep ":" [
+      "PATH=${
+        lib.concatStringsSep ":" [
           "/root/.nix-profile/bin"
           "/nix/var/nix/profiles/default/bin"
           "/nix/var/nix/profiles/default/sbin"
-      ]}"
+        ]
-      "MANPATH=${lib.concatStringsSep ":" [
+      }"
+      "MANPATH=${
+        lib.concatStringsSep ":" [
           "/root/.nix-profile/share/man"
           "/nix/var/nix/profiles/default/share/man"
-      ]}"
+        ]
+      }"
       "SSL_CERT_FILE=/nix/var/nix/profiles/default/etc/ssl/certs/ca-bundle.crt"
       "GIT_SSL_CAINFO=/nix/var/nix/profiles/default/etc/ssl/certs/ca-bundle.crt"
       "NIX_SSL_CERT_FILE=/nix/var/nix/profiles/default/etc/ssl/certs/ca-bundle.crt"
       "NIX_PATH=/nix/var/nix/profiles/per-user/root/channels:/root/.nix-defexpr/channels"
     ];
   };
-
 }

flake.nix

@@ -12,10 +12,20 @@
         nixpkgs-stable.follows = "nixpkgs";
       };
     };
-    flake-compat = { url = "github:edolstra/flake-compat"; flake = false; };
+    flake-compat = {
+      url = "github:edolstra/flake-compat";
+      flake = false;
+    };
   };
 
-  outputs = { self, nixpkgs, nixpkgs-regression, pre-commit-hooks, flake-compat }:
+  outputs =
+    {
+      self,
+      nixpkgs,
+      nixpkgs-regression,
+      pre-commit-hooks,
+      flake-compat,
+    }:
 
     let
       inherit (nixpkgs) lib;
@@ -27,73 +37,98 @@
 
       version = lib.fileContents ./.version + versionSuffix;
       versionSuffix =
-        if officialRelease
+        if officialRelease then
-        then ""
+          ""
-        else "pre${builtins.substring 0 8 (self.lastModifiedDate or self.lastModified or "19700101")}_${self.shortRev or "dirty"}";
+        else
+          "pre${
+            builtins.substring 0 8 (self.lastModifiedDate or self.lastModified or "19700101")
+          }_${self.shortRev or "dirty"}";
 
       linux32BitSystems = [ "i686-linux" ];
-      linux64BitSystems = [ "x86_64-linux" "aarch64-linux" ];
+      linux64BitSystems = [
+        "x86_64-linux"
+        "aarch64-linux"
+      ];
       linuxSystems = linux32BitSystems ++ linux64BitSystems;
-      darwinSystems = [ "x86_64-darwin" "aarch64-darwin" ];
+      darwinSystems = [
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ];
       systems = linuxSystems ++ darwinSystems;
 
       crossSystems = [
-        "armv6l-linux" "armv7l-linux"
+        "armv6l-linux"
-        "x86_64-freebsd13" "x86_64-netbsd"
+        "armv7l-linux"
+        "x86_64-freebsd13"
+        "x86_64-netbsd"
       ];
 
-      stdenvs = [ "gccStdenv" "clangStdenv" "stdenv" "libcxxStdenv" "ccacheStdenv" ];
+      stdenvs = [
+        "gccStdenv"
+        "clangStdenv"
+        "stdenv"
+        "libcxxStdenv"
+        "ccacheStdenv"
+      ];
 
       forAllSystems = lib.genAttrs systems;
 
       forAllCrossSystems = lib.genAttrs crossSystems;
 
-      forAllStdenvs = f:
+      forAllStdenvs =
-        lib.listToAttrs
+        f:
-          (map
+        lib.listToAttrs (
-            (stdenvName: {
+          map (stdenvName: {
             name = "${stdenvName}Packages";
             value = f stdenvName;
-            })
+          }) stdenvs
-            stdenvs);
+        );
 
       # Memoize nixpkgs for different platforms for efficiency.
-      nixpkgsFor = forAllSystems
+      nixpkgsFor = forAllSystems (
-        (system: let
+        system:
-          make-pkgs = crossSystem: stdenv: import nixpkgs {
+        let
+          make-pkgs =
+            crossSystem: stdenv:
+            import nixpkgs {
               localSystem = {
                 inherit system;
               };
-            crossSystem = if crossSystem == null then null else {
+              crossSystem =
+                if crossSystem == null then
+                  null
+                else
+                  {
                     system = crossSystem;
-            } // lib.optionalAttrs (crossSystem == "x86_64-freebsd13") {
+                  }
-              useLLVM = true;
+                  // lib.optionalAttrs (crossSystem == "x86_64-freebsd13") { useLLVM = true; };
-            };
               overlays = [
                 (overlayFor (p: p.${stdenv}))
-              (final: prev: {
+                (final: prev: { nixfmt = final.callPackage ./nix-support/nixfmt.nix { }; })
-                nixfmt = final.callPackage ./nix-support/nixfmt.nix {};
-              })
               ];
 
               config.permittedInsecurePackages = [ "nix-2.13.6" ];
             };
           stdenvs = forAllStdenvs (make-pkgs null);
           native = stdenvs.stdenvPackages;
-        in {
+        in
+        {
           inherit stdenvs native;
           static = native.pkgsStatic;
           cross = forAllCrossSystems (crossSystem: make-pkgs crossSystem "stdenv");
-        });
+        }
+      );
 
-      binaryTarball = nix: pkgs:
+      binaryTarball =
+        nix: pkgs:
         let
           inherit (pkgs) buildPackages;
           installerClosureInfo = buildPackages.closureInfo { rootPaths = [ nix ]; };
         in
 
         buildPackages.runCommand "nix-binary-tarball-${version}"
-          { #nativeBuildInputs = lib.optional (system != "aarch64-linux") shellcheck;
+          {
+            #nativeBuildInputs = lib.optional (system != "aarch64-linux") shellcheck;
             meta.description = "Distribution-independent Nix bootstrap binaries for ${pkgs.system}";
           }
           ''
@@ -114,17 +149,18 @@
               $(cat ${installerClosureInfo}/store-paths)
           '';
 
-      overlayFor = getStdenv: final: prev:
+      overlayFor =
+        getStdenv: final: prev:
         let
           currentStdenv = getStdenv final;
-        in {
+        in
+        {
           nixStable = prev.nix;
 
           # Forward from the previous stage as we don’t want it to pick the lowdown override
           nixUnstable = prev.nixUnstable;
 
-          build-release-notes =
+          build-release-notes = final.buildPackages.callPackage ./maintainers/build-release-notes.nix { };
-            final.buildPackages.callPackage ./maintainers/build-release-notes.nix { };
           clangbuildanalyzer = final.buildPackages.callPackage ./misc/clangbuildanalyzer.nix { };
 
           default-busybox-sandbox-shell = final.busybox.override {
@@ -161,8 +197,8 @@
           # for consumers of this flake.
           boehmgc-nix = final.nix.boehmgc-nix;
         };
-
+    in
-    in {
+    {
       # A Nixpkgs overlay that overrides the 'nix' and
       # 'nix.perl-bindings' packages.
       overlays.default = overlayFor (p: p.stdenv);
@@ -172,32 +208,38 @@
         # Binary package for various platforms.
         build = forAllSystems (system: self.packages.${system}.nix);
 
-        rl-next = forAllSystems (system:
+        rl-next = forAllSystems (
+          system:
           let
-            rl-next-check = name: dir:
+            rl-next-check =
-              let pkgs = nixpkgsFor.${system}.native;
+              name: dir:
-              in pkgs.buildPackages.runCommand "test-${name}-release-notes" { } ''
+              let
+                pkgs = nixpkgsFor.${system}.native;
+              in
+              pkgs.buildPackages.runCommand "test-${name}-release-notes" { } ''
                 LANG=C.UTF-8 ${lib.getExe pkgs.build-release-notes} ${dir} >$out
               '';
           in
           {
             user = rl-next-check "rl-next" ./doc/manual/rl-next;
             dev = rl-next-check "rl-next-dev" ./doc/manual/rl-next-dev;
-            });
+          }
+        );
 
         # FIXME(Qyriad): remove this when the migration to Meson has been completed.
         # NOTE: mesonBuildClang depends on mesonBuild depends on build to avoid OOMs
         # on aarch64 builders caused by too many parallel compiler/linker processes.
-        mesonBuild = forAllSystems (system:
+        mesonBuild = forAllSystems (
-          (self.packages.${system}.nix.override {
+          system:
-            buildWithMeson = true;
+          (self.packages.${system}.nix.override { buildWithMeson = true; }).overrideAttrs (prev: {
-          }).overrideAttrs (prev: {
             buildInputs = prev.buildInputs ++ [ self.packages.${system}.nix ];
-          }));
+          })
-        mesonBuildClang = forAllSystems (system:
+        );
-          (nixpkgsFor.${system}.stdenvs.clangStdenvPackages.nix.override {
+        mesonBuildClang = forAllSystems (
-              buildWithMeson = true;
+          system:
-          }).overrideAttrs (prev: {
+          (nixpkgsFor.${system}.stdenvs.clangStdenvPackages.nix.override { buildWithMeson = true; })
+          .overrideAttrs
+            (prev: {
               buildInputs = prev.buildInputs ++ [ self.hydraJobs.mesonBuild.${system} ];
             })
         );
@@ -207,13 +249,16 @@
 
         # Binary tarball for various platforms, containing a Nix store
         # with the closure of 'nix' package.
-        binaryTarball = forAllSystems (system: binaryTarball nixpkgsFor.${system}.native.nix nixpkgsFor.${system}.native);
+        binaryTarball = forAllSystems (
+          system: binaryTarball nixpkgsFor.${system}.native.nix nixpkgsFor.${system}.native
+        );
 
         # docker image with Nix inside
         dockerImage = lib.genAttrs linux64BitSystems (system: self.packages.${system}.dockerImage);
 
         # API docs for Nix's unstable internal C++ interfaces.
-        internal-api-docs = let
+        internal-api-docs =
+          let
             nixpkgs = nixpkgsFor.x86_64-linux.native;
             inherit (nixpkgs) pkgs;
 
@@ -239,8 +284,7 @@
           # on a particular version of Nixpkgs.
           evalNixpkgs =
             with nixpkgsFor.x86_64-linux.native;
-            runCommand "eval-nixos" { buildInputs = [ nix ]; }
+            runCommand "eval-nixos" { buildInputs = [ nix ]; } ''
-              ''
               type -p nix-env
               # Note: we're filtering out nixos-install-tools because https://github.com/NixOS/nixpkgs/pull/153594#issuecomment-1020530593.
               time nix-env --store dummy:// -f ${nixpkgs-regression} -qaP --drv-path | sort | grep -v nixos-install-tools > packages
@@ -248,21 +292,23 @@
               mkdir $out
             '';
 
-          nixpkgsLibTests =
+          nixpkgsLibTests = forAllSystems (
-            forAllSystems (system:
+            system:
-              import (nixpkgs + "/lib/tests/release.nix")
+            import (nixpkgs + "/lib/tests/release.nix") {
-                { pkgs = nixpkgsFor.${system}.native;
+              pkgs = nixpkgsFor.${system}.native;
               nixVersions = [ self.packages.${system}.nix ];
             }
           );
         };
 
-        pre-commit = builtins.mapAttrs (system: pre-commit-lib: pre-commit-lib.run {
+        pre-commit = builtins.mapAttrs (
+          system: pre-commit-lib:
+          pre-commit-lib.run {
             src = self;
             hooks = {
               no-commit-to-branch = {
                 enable = true;
-              settings.branch = ["main"];
+                settings.branch = [ "main" ];
               };
               check-case-conflicts.enable = true;
               check-executables-have-shebangs = {
@@ -306,12 +352,15 @@
                   [ pkgs.nixfmt ];
               };
             };
-        }) pre-commit-hooks.lib;
+          }
+        ) pre-commit-hooks.lib;
       };
 
       # NOTE *do not* add fresh derivations to checks, always add them to
       # hydraJobs first (so CI will pick them up) and only link them here
-      checks = forAllSystems (system: {
+      checks = forAllSystems (
+        system:
+        {
           # FIXME(Qyriad): remove this when the migration to Meson has been completed.
           mesonBuild = self.hydraJobs.mesonBuild.${system};
           mesonBuildClang = self.hydraJobs.mesonBuildClang.${system};
@@ -321,22 +370,30 @@
           rl-next = self.hydraJobs.rl-next.${system}.user;
           rl-next-dev = self.hydraJobs.rl-next.${system}.dev;
           pre-commit = self.hydraJobs.pre-commit.${system};
-      } // (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
+        }
+        // (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
           dockerImage = self.hydraJobs.dockerImage.${system};
-      });
+        }
+      );
 
-      packages = forAllSystems (system: rec {
+      packages = forAllSystems (
+        system:
+        rec {
           inherit (nixpkgsFor.${system}.native) nix;
           default = nix;
-      } // (lib.optionalAttrs (builtins.elem system linux64BitSystems) {
+        }
+        // (
+          lib.optionalAttrs (builtins.elem system linux64BitSystems) {
             nix-static = nixpkgsFor.${system}.static.nix;
             dockerImage =
               let
                 pkgs = nixpkgsFor.${system}.native;
-            image = import ./docker.nix { inherit pkgs; tag = version; };
+                image = import ./docker.nix {
+                  inherit pkgs;
+                  tag = version;
+                };
               in
-          pkgs.runCommand
+              pkgs.runCommand "docker-image-tarball-${version}"
-            "docker-image-tarball-${version}"
                 { meta.description = "Docker image with Nix for ${system}"; }
                 ''
                   mkdir -p $out/nix-support
@@ -344,44 +401,64 @@
                   ln -s ${image} $image
                   echo "file binary-dist $image" >> $out/nix-support/hydra-build-products
                 '';
-      } // builtins.listToAttrs (map
+          }
-          (crossSystem: {
+          // builtins.listToAttrs (
+            map (crossSystem: {
               name = "nix-${crossSystem}";
               value = nixpkgsFor.${system}.cross.${crossSystem}.nix;
-          })
+            }) crossSystems
-          crossSystems)
+          )
-        // builtins.listToAttrs (map
+          // builtins.listToAttrs (
-          (stdenvName: {
+            map (stdenvName: {
               name = "nix-${stdenvName}";
               value = nixpkgsFor.${system}.stdenvs."${stdenvName}Packages".nix;
-          })
+            }) stdenvs
-          stdenvs)));
+          )
+        )
+      );
 
-      devShells = let
+      devShells =
-        makeShell = pkgs: stdenv:
+        let
+          makeShell =
+            pkgs: stdenv:
             let
               nix = pkgs.callPackage ./package.nix {
                 inherit stdenv versionSuffix;
                 busybox-sandbox-shell = pkgs.busybox-sandbox-shell or pkgs.default-busybox-sandbox;
                 forDevShell = true;
               };
-            pre-commit = self.hydraJobs.pre-commit.${pkgs.system} or {};
+              pre-commit = self.hydraJobs.pre-commit.${pkgs.system} or { };
             in
             (nix.override {
               buildUnreleasedNotes = true;
               officialRelease = false;
-            }).overrideAttrs (prev: {
+            }).overrideAttrs
+              (
+                prev:
+                {
                   # Required for clang-tidy checks
-              buildInputs = prev.buildInputs
+                  buildInputs =
-                ++ [ pkgs.just pkgs.nixfmt ]
+                    prev.buildInputs
+                    ++ [
+                      pkgs.just
+                      pkgs.nixfmt
+                    ]
                     ++ lib.optional (pre-commit ? enabledPackages) pre-commit.enabledPackages
-                ++ lib.optionals (stdenv.cc.isClang) [ pkgs.llvmPackages.llvm pkgs.llvmPackages.clang-unwrapped.dev ];
+                    ++ lib.optionals (stdenv.cc.isClang) [
-              nativeBuildInputs = prev.nativeBuildInputs
+                      pkgs.llvmPackages.llvm
+                      pkgs.llvmPackages.clang-unwrapped.dev
+                    ];
+                  nativeBuildInputs =
+                    prev.nativeBuildInputs
                     ++ lib.optional (stdenv.cc.isClang && !stdenv.buildPlatform.isDarwin) pkgs.buildPackages.bear
                     # Required for clang-tidy checks
-                ++ lib.optionals (stdenv.cc.isClang) [ pkgs.buildPackages.cmake pkgs.buildPackages.ninja pkgs.buildPackages.llvmPackages.llvm.dev ]
+                    ++ lib.optionals (stdenv.cc.isClang) [
-                ++ lib.optional
+                      pkgs.buildPackages.cmake
-                  (stdenv.cc.isClang && stdenv.hostPlatform == stdenv.buildPlatform)
+                      pkgs.buildPackages.ninja
+                      pkgs.buildPackages.llvmPackages.llvm.dev
+                    ]
+                    ++
+                      lib.optional (stdenv.cc.isClang && stdenv.hostPlatform == stdenv.buildPlatform)
                         # for some reason that seems accidental and was changed in
                         # NixOS 24.05-pre, clang-tools is pinned to LLVM 14 when
                         # default LLVM is newer.
@@ -410,22 +487,32 @@
 
                     ${lib.optionalString (pre-commit ? shellHook) pre-commit.shellHook}
                   '';
-            } // lib.optionalAttrs (stdenv.buildPlatform.isLinux && pkgs.glibcLocales != null) {
+                }
+                // lib.optionalAttrs (stdenv.buildPlatform.isLinux && pkgs.glibcLocales != null) {
                   # Required to make non-NixOS Linux not complain about missing locale files during configure in a dev shell
                   LOCALE_ARCHIVE = "${lib.getLib pkgs.glibcLocales}/lib/locale/locale-archive";
-            });
+                }
+              );
         in
-        forAllSystems (system:
+        forAllSystems (
+          system:
           let
-            makeShells = prefix: pkgs:
+            makeShells =
-              lib.mapAttrs'
+              prefix: pkgs:
-              (k: v: lib.nameValuePair "${prefix}-${k}" v)
+              lib.mapAttrs' (k: v: lib.nameValuePair "${prefix}-${k}" v) (
-              (forAllStdenvs (stdenvName: makeShell pkgs pkgs.${stdenvName}));
+                forAllStdenvs (stdenvName: makeShell pkgs pkgs.${stdenvName})
+              );
           in
-            (makeShells "native" nixpkgsFor.${system}.native) //
+          (makeShells "native" nixpkgsFor.${system}.native)
-            (makeShells "static" nixpkgsFor.${system}.static) //
+          // (makeShells "static" nixpkgsFor.${system}.static)
-            (forAllCrossSystems (crossSystem: let pkgs = nixpkgsFor.${system}.cross.${crossSystem}; in makeShell pkgs pkgs.stdenv)) //
+          // (forAllCrossSystems (
-            {
+            crossSystem:
+            let
+              pkgs = nixpkgsFor.${system}.cross.${crossSystem};
+            in
+            makeShell pkgs pkgs.stdenv
+          ))
+          // {
             default = self.devShells.${system}.native-stdenvPackages;
           }
         );

lix-doc/package.nix

@@ -1,7 +1,4 @@
-{
+{ rustPlatform, lib }:
-  rustPlatform,
-  lib
-}:
 
 rustPlatform.buildRustPackage {
   name = "lix-doc";

maintainers/build-release-notes.nix

@@ -1,4 +1,8 @@
-{ lib, python3, writeShellScriptBin }:
+{
+  lib,
+  python3,
+  writeShellScriptBin,
+}:
 
 writeShellScriptBin "build-release-notes" ''
   exec ${lib.getExe (python3.withPackages (p: [ p.python-frontmatter ]))} \

misc/clangbuildanalyzer.nix

@@ -1,6 +1,11 @@
 # Upstreaming here, can be deleted once it's upstreamed:
 # https://github.com/NixOS/nixpkgs/pull/297102
-{ stdenv, lib, cmake, fetchFromGitHub }:
+{
+  stdenv,
+  lib,
+  cmake,
+  fetchFromGitHub,
+}:
 stdenv.mkDerivation (finalAttrs: {
   pname = "clangbuildanalyzer";
   version = "1.5.0";
@@ -12,9 +17,7 @@ stdenv.mkDerivation (finalAttrs: {
     sha256 = "sha256-kmgdk634zM0W0OoRoP/RzepArSipa5bNqdVgdZO9gxo=";
   };
 
-  nativeBuildInputs = [
+  nativeBuildInputs = [ cmake ];
-    cmake
-  ];
 
   meta = {
     description = "Tool for analyzing Clang's -ftrace-time files";

package.nix

@@ -69,9 +69,7 @@
   __forDefaults ? {
     canRunInstalled = stdenv.buildPlatform.canExecute stdenv.hostPlatform;
 
-    boehmgc-nix = (boehmgc.override {
+    boehmgc-nix = (boehmgc.override { enableLargeConfig = true; }).overrideAttrs {
-      enableLargeConfig = true;
-    }).overrideAttrs {
       patches = [
         # We do *not* include prev.patches (which doesn't exist in normal pkgs.boehmgc anyway)
         # because if the caller of this package passed a patched boehm as `boehmgc` instead of
@@ -85,20 +83,22 @@
 
     lix-doc = pkgs.callPackage ./lix-doc/package.nix { };
   },
-}: let
+}:
+let
   inherit (__forDefaults) canRunInstalled;
   inherit (lib) fileset;
 
   version = lib.fileContents ./.version + versionSuffix;
 
   aws-sdk-cpp-nix = aws-sdk-cpp.override {
-    apis = [ "s3" "transfer" ];
+    apis = [
+      "s3"
+      "transfer"
+    ];
     customMemoryManagement = false;
   };
 
-  testConfigureFlags = [
+  testConfigureFlags = [ "RAPIDCHECK_HEADERS=${lib.getDev rapidcheck}/extras/gtest/include" ];
-    "RAPIDCHECK_HEADERS=${lib.getDev rapidcheck}/extras/gtest/include"
-  ];
 
   # The internal API docs need these for the build, but if we're not building
   # Nix itself, then these don't need to be propagated.
@@ -120,34 +120,40 @@
     ./README.md
   ];
 
-  topLevelBuildFiles = fileset.unions ([
+  topLevelBuildFiles = fileset.unions (
+    [
       ./local.mk
       ./Makefile
       ./Makefile.config.in
       ./mk
-  ] ++ lib.optionals buildWithMeson [
+    ]
+    ++ lib.optionals buildWithMeson [
       ./meson.build
       ./meson.options
       ./meson
       ./scripts/meson.build
-  ]);
+    ]
+  );
 
   functionalTestFiles = fileset.unions [
     ./tests/functional
     ./tests/unit
     (fileset.fileFilter (f: lib.strings.hasPrefix "nix-profile" f.name) ./scripts)
   ];
-
+in
-in stdenv.mkDerivation (finalAttrs: {
+stdenv.mkDerivation (finalAttrs: {
   inherit pname version;
 
   src = fileset.toSource {
     root = ./.;
-    fileset = fileset.intersection baseFiles (fileset.unions ([
+    fileset = fileset.intersection baseFiles (
+      fileset.unions (
+        [
           configureFiles
           topLevelBuildFiles
           functionalTestFiles
-    ] ++ lib.optionals (!finalAttrs.dontBuild || internalApiDocs) [
+        ]
+        ++ lib.optionals (!finalAttrs.dontBuild || internalApiDocs) [
           ./boehmgc-coroutine-sp-fallback.diff
           ./doc
           ./misc
@@ -155,13 +161,19 @@ in stdenv.mkDerivation (finalAttrs: {
           ./src
           ./COPYING
           ./scripts/local.mk
-    ]));
+        ]
+      )
+    );
   };
 
   VERSION_SUFFIX = versionSuffix;
 
-  outputs = [ "out" ]
+  outputs =
-    ++ lib.optionals (!finalAttrs.dontBuild) [ "dev" "doc" ];
+    [ "out" ]
+    ++ lib.optionals (!finalAttrs.dontBuild) [
+      "dev"
+      "doc"
+    ];
 
   dontBuild = false;
 
@@ -173,16 +185,20 @@ in stdenv.mkDerivation (finalAttrs: {
   # We only include CMake so that Meson can locate toml11, which only ships CMake dependency metadata.
   dontUseCmakeConfigure = true;
 
-  nativeBuildInputs = [
+  nativeBuildInputs =
+    [
       bison
       flex
       python3
-  ] ++ [
+    ]
+    ++ [
       (lib.getBin lowdown)
       mdbook
       mdbook-linkcheck
       autoconf-archive
-  ] ++ lib.optional (!buildWithMeson) autoreconfHook ++ [
+    ]
+    ++ lib.optional (!buildWithMeson) autoreconfHook
+    ++ [
       pkg-config
 
       # Tests
@@ -190,7 +206,8 @@ in stdenv.mkDerivation (finalAttrs: {
       mercurial
       jq
       lsof
-  ] ++ lib.optional stdenv.hostPlatform.isLinux util-linuxMinimal
+    ]
+    ++ lib.optional stdenv.hostPlatform.isLinux util-linuxMinimal
     ++ lib.optional (!officialRelease && buildUnreleasedNotes) build-release-notes
     ++ lib.optional internalApiDocs doxygen
     ++ lib.optionals buildWithMeson [
@@ -199,7 +216,8 @@ in stdenv.mkDerivation (finalAttrs: {
       cmake
     ];
 
-  buildInputs = [
+  buildInputs =
+    [
       curl
       bzip2
       xz
@@ -214,12 +232,14 @@ in stdenv.mkDerivation (finalAttrs: {
       toml11
       lix-doc
     ]
-    ++ lib.optionals stdenv.hostPlatform.isLinux [ libseccomp busybox-sandbox-shell ]
+    ++ lib.optionals stdenv.hostPlatform.isLinux [
+      libseccomp
+      busybox-sandbox-shell
+    ]
     ++ lib.optional stdenv.hostPlatform.isx86_64 libcpuid
     # There have been issues building these dependencies
     ++ lib.optional (stdenv.hostPlatform == stdenv.buildPlatform) aws-sdk-cpp-nix
-    ++ lib.optionals (finalAttrs.dontBuild) maybePropagatedInputs
+    ++ lib.optionals (finalAttrs.dontBuild) maybePropagatedInputs;
-  ;
 
   checkInputs = [
     gtest
@@ -228,9 +248,7 @@ in stdenv.mkDerivation (finalAttrs: {
 
   propagatedBuildInputs = lib.optionals (!finalAttrs.dontBuild) maybePropagatedInputs;
 
-  disallowedReferences = [
+  disallowedReferences = [ boost ];
-    boost
-  ];
 
   # Needed for Meson to find Boost.
   # https://github.com/NixOS/nixpkgs/issues/86131.
@@ -239,23 +257,27 @@ in stdenv.mkDerivation (finalAttrs: {
     BOOST_LIBRARYDIR = "${lib.getLib boost}/lib";
   };
 
-  preConfigure = lib.optionalString (!finalAttrs.dontBuild && !stdenv.hostPlatform.isStatic) ''
+  preConfigure =
+    lib.optionalString (!finalAttrs.dontBuild && !stdenv.hostPlatform.isStatic) ''
       # Copy libboost_context so we don't get all of Boost in our closure.
       # https://github.com/NixOS/nixpkgs/issues/45462
       mkdir -p $out/lib
       cp -pd ${boost}/lib/{libboost_context*,libboost_thread*,libboost_system*} $out/lib
       rm -f $out/lib/*.a
-  '' + lib.optionalString (!finalAttrs.dontBuild && stdenv.hostPlatform.isLinux) ''
+    ''
+    + lib.optionalString (!finalAttrs.dontBuild && stdenv.hostPlatform.isLinux) ''
       chmod u+w $out/lib/*.so.*
       patchelf --set-rpath $out/lib:${stdenv.cc.cc.lib}/lib $out/lib/libboost_thread.so.*
-  '' + lib.optionalString (!finalAttrs.dontBuild && stdenv.hostPlatform.isDarwin) ''
+    ''
+    + lib.optionalString (!finalAttrs.dontBuild && stdenv.hostPlatform.isDarwin) ''
       for LIB in $out/lib/*.dylib; do
         chmod u+w $LIB
         install_name_tool -id $LIB $LIB
         install_name_tool -delete_rpath ${boost}/lib/ $LIB || true
       done
       install_name_tool -change ${boost}/lib/libboost_system.dylib $out/lib/libboost_system.dylib $out/lib/libboost_thread.dylib
-  '' + ''
+    ''
+    + ''
       # Workaround https://github.com/NixOS/nixpkgs/issues/294890.
       if [[ -n "''${doCheck:-}" ]]; then
         appendToVar configureFlags "--enable-tests"
@@ -264,21 +286,18 @@ in stdenv.mkDerivation (finalAttrs: {
       fi
     '';
 
-  configureFlags = [
+  configureFlags =
-    "--with-boost=${boost}/lib"
+    [ "--with-boost=${boost}/lib" ]
-  ] ++ lib.optionals stdenv.isLinux [
+    ++ lib.optionals stdenv.isLinux [ "--with-sandbox-shell=${busybox-sandbox-shell}/bin/busybox" ]
-    "--with-sandbox-shell=${busybox-sandbox-shell}/bin/busybox"
+    ++ lib.optionals (
-  ] ++ lib.optionals (stdenv.isLinux && !(stdenv.hostPlatform.isStatic && stdenv.system == "aarch64-linux")) [
+      stdenv.isLinux && !(stdenv.hostPlatform.isStatic && stdenv.system == "aarch64-linux")
-    "LDFLAGS=-fuse-ld=gold"
+    ) [ "LDFLAGS=-fuse-ld=gold" ]
-  ]
     ++ lib.optional stdenv.hostPlatform.isStatic "--enable-embedded-sandbox-shell"
     ++ lib.optionals (finalAttrs.doCheck || internalApiDocs) testConfigureFlags
     ++ lib.optional (!canRunInstalled) "--disable-doc-gen"
     ++ [ (lib.enableFeature internalApiDocs "internal-api-docs") ]
     ++ lib.optional (!forDevShell) "--sysconfdir=/etc"
-    ++ [
+    ++ [ "TOML11_HEADERS=${lib.getDev toml11}/include" ];
-      "TOML11_HEADERS=${lib.getDev toml11}/include"
-    ];
 
   mesonBuildType = lib.optional (buildWithMeson || forDevShell) "debugoptimized";
 
@@ -290,26 +309,28 @@ in stdenv.mkDerivation (finalAttrs: {
 
   doCheck = true;
 
-  mesonCheckFlags = lib.optionals (buildWithMeson || forDevShell) [
+  mesonCheckFlags = lib.optionals (buildWithMeson || forDevShell) [ "--suite=check" ];
-    "--suite=check"
-  ];
 
   installFlags = "sysconfdir=$(out)/etc";
 
-  postInstall = lib.optionalString (!finalAttrs.dontBuild) ''
+  postInstall =
+    lib.optionalString (!finalAttrs.dontBuild) ''
       mkdir -p $doc/nix-support
       echo "doc manual $doc/share/doc/nix/manual" >> $doc/nix-support/hydra-build-products
-  '' + lib.optionalString stdenv.hostPlatform.isStatic ''
+    ''
+    + lib.optionalString stdenv.hostPlatform.isStatic ''
       mkdir -p $out/nix-support
       echo "file binary-dist $out/bin/nix" >> $out/nix-support/hydra-build-products
-  '' + lib.optionalString stdenv.isDarwin ''
+    ''
+    + lib.optionalString stdenv.isDarwin ''
       for lib in libnixutil.dylib libnixexpr.dylib; do
         install_name_tool \
           -change "${lib.getLib boost}/lib/libboost_context.dylib" \
           "$out/lib/libboost_context.dylib" \
           "$out/lib/$lib"
       done
-  '' + lib.optionalString internalApiDocs ''
+    ''
+    + lib.optionalString internalApiDocs ''
       mkdir -p $out/nix-support
       echo "doc internal-api-docs $out/share/doc/nix/internal-api/html" >> "$out/nix-support/hydra-build-products"
     '';
@@ -318,9 +339,7 @@ in stdenv.mkDerivation (finalAttrs: {
   installCheckFlags = "sysconfdir=$(out)/etc";
   installCheckTarget = "installcheck"; # work around buggy detection in stdenv
 
-  mesonInstallCheckFlags = [
+  mesonInstallCheckFlags = [ "--suite=installcheck" ];
-    "--suite=installcheck"
-  ];
 
   preInstallCheck = lib.optionalString stdenv.hostPlatform.isDarwin ''
     export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
@@ -338,14 +357,11 @@ in stdenv.mkDerivation (finalAttrs: {
   strictDeps = true;
 
   # strictoverflow is disabled because we trap on signed overflow instead
-  hardeningDisable = [ "strictoverflow" ]
+  hardeningDisable = [ "strictoverflow" ] ++ lib.optional stdenv.hostPlatform.isStatic "pie";
-    ++ lib.optional stdenv.hostPlatform.isStatic "pie";
 
   meta.platforms = lib.platforms.unix;
 
-  passthru.perl-bindings = pkgs.callPackage ./perl {
+  passthru.perl-bindings = pkgs.callPackage ./perl { inherit fileset stdenv buildWithMeson; };
-    inherit fileset stdenv buildWithMeson;
-  };
 
   # Export the patched version of boehmgc.
   # flake.nix exports that into its overlay.

perl/default.nix

@@ -1,22 +1,36 @@
-{ lib, fileset
+{
-, stdenv
+  lib,
-, perl, perlPackages
+  fileset,
-, autoconf-archive, autoreconfHook, pkg-config
+  stdenv,
-, nix, curl, bzip2, xz, boost, libsodium, darwin
+  perl,
-, meson
+  perlPackages,
-, ninja
+  autoconf-archive,
-, buildWithMeson ? false,
+  autoreconfHook,
+  pkg-config,
+  nix,
+  curl,
+  bzip2,
+  xz,
+  boost,
+  libsodium,
+  darwin,
+  meson,
+  ninja,
+  buildWithMeson ? false,
 }:
 
-perl.pkgs.toPerlModule (stdenv.mkDerivation {
+perl.pkgs.toPerlModule (
+  stdenv.mkDerivation {
     name = "nix-perl-${nix.version}";
 
     src = fileset.toSource {
       root = ../.;
-    fileset = fileset.unions ([
+      fileset = fileset.unions (
+        [
           ../.version
           ./lib
-    ] ++ lib.optionals (!buildWithMeson) [
+        ]
+        ++ lib.optionals (!buildWithMeson) [
           # FIXME(Qyriad): What the hell is this?
           # What is it used for and do we still need it?
           ./MANIFEST
@@ -26,23 +40,25 @@ perl.pkgs.toPerlModule (stdenv.mkDerivation {
           ./Makefile.config.in
           ./configure.ac
           ./local.mk
-    ] ++ lib.optionals buildWithMeson [
+        ]
-      ./meson.build
+        ++ lib.optionals buildWithMeson [ ./meson.build ]
-    ]);
+      );
     };
 
-  nativeBuildInputs = [
+    nativeBuildInputs =
-    pkg-config
+      [ pkg-config ]
-  ] ++ lib.optionals (!buildWithMeson) [
+      ++ lib.optionals (!buildWithMeson) [
         autoconf-archive
         autoreconfHook
-  ] ++ lib.optionals buildWithMeson [
+      ]
+      ++ lib.optionals buildWithMeson [
         meson
         ninja
       ];
 
     buildInputs =
-    [ nix
+      [
+        nix
         curl
         bzip2
         xz
@@ -60,4 +76,5 @@ perl.pkgs.toPerlModule (stdenv.mkDerivation {
     enableParallelBuilding = true;
 
     postUnpack = "sourceRoot=$sourceRoot/perl";
-})
+  }
+)

src/libexpr/fetchurl.nix

@@ -1,27 +1,55 @@
-{ system ? "" # obsolete
+{
-, url
+  system ? "", # obsolete
-, hash ? "" # an SRI hash
+  url,
+  hash ? "", # an SRI hash
 
-# Legacy hash specification
+  # Legacy hash specification
-, md5 ? "", sha1 ? "", sha256 ? "", sha512 ? ""
+  md5 ? "",
-, outputHash ?
+  sha1 ? "",
-    if hash != "" then hash else if sha512 != "" then sha512 else if sha1 != "" then sha1 else if md5 != "" then md5 else sha256
+  sha256 ? "",
-, outputHashAlgo ?
+  sha512 ? "",
-    if hash != "" then "" else if sha512 != "" then "sha512" else if sha1 != "" then "sha1" else if md5 != "" then "md5" else "sha256"
+  outputHash ?
+    if hash != "" then
+      hash
+    else if sha512 != "" then
+      sha512
+    else if sha1 != "" then
+      sha1
+    else if md5 != "" then
+      md5
+    else
+      sha256,
+  outputHashAlgo ?
+    if hash != "" then
+      ""
+    else if sha512 != "" then
+      "sha512"
+    else if sha1 != "" then
+      "sha1"
+    else if md5 != "" then
+      "md5"
+    else
+      "sha256",
 
-, executable ? false
+  executable ? false,
-, unpack ? false
+  unpack ? false,
-, name ? baseNameOf (toString url)
+  name ? baseNameOf (toString url),
-, impure ? false
+  impure ? false,
 }:
 
-derivation ({
+derivation (
+  {
     builder = "builtin:fetchurl";
 
     # New-style output content requirements.
     outputHashMode = if unpack || executable then "recursive" else "flat";
 
-  inherit name url executable unpack;
+    inherit
+      name
+      url
+      executable
+      unpack
+      ;
 
     system = "builtin";
 
@@ -33,11 +61,15 @@ derivation ({
       # easy proxy configuration.  This is impure, but a fixed-output
       # derivation like fetchurl is allowed to do so since its result is
       # by definition pure.
-    "http_proxy" "https_proxy" "ftp_proxy" "all_proxy" "no_proxy"
+      "http_proxy"
+      "https_proxy"
+      "ftp_proxy"
+      "all_proxy"
+      "no_proxy"
     ];
 
     # To make "nix-prefetch-url" work.
     urls = [ url ];
-} // (if impure
+  }
-      then { __impure = true; }
+  // (if impure then { __impure = true; } else { inherit outputHashAlgo outputHash; })
-      else { inherit outputHashAlgo outputHash; }))
+)

src/libexpr/flake/call-flake.nix

@@ -4,15 +4,15 @@ let
 
   lockFile = builtins.fromJSON lockFileStr;
 
-  allNodes =
+  allNodes = builtins.mapAttrs (
-    builtins.mapAttrs
+    key: node:
-      (key: node:
     let
 
       sourceInfo =
-            if key == lockFile.root
+        if key == lockFile.root then
-            then rootSrc
+          rootSrc
-            else fetchTree (node.info or {} // removeAttrs node.locked ["dir"]);
+        else
+          fetchTree (node.info or { } // removeAttrs node.locked [ "dir" ]);
 
       subdir = if key == lockFile.root then rootSubdir else node.locked.dir or "";
 
@@ -20,23 +20,22 @@ let
 
       flake = import (outPath + "/flake.nix");
 
-          inputs = builtins.mapAttrs
+      inputs = builtins.mapAttrs (inputName: inputSpec: allNodes.${resolveInput inputSpec}) (
-            (inputName: inputSpec: allNodes.${resolveInput inputSpec})
+        node.inputs or { }
-            (node.inputs or {});
+      );
 
       # Resolve a input spec into a node name. An input spec is
       # either a node name, or a 'follows' path from the root
       # node.
-          resolveInput = inputSpec:
+      resolveInput =
-              if builtins.isList inputSpec
+        inputSpec: if builtins.isList inputSpec then getInputByPath lockFile.root inputSpec else inputSpec;
-              then getInputByPath lockFile.root inputSpec
-              else inputSpec;
 
       # Follow an input path (e.g. ["dwarffs" "nixpkgs"]) from the
       # root node, returning the final node.
-          getInputByPath = nodeName: path:
+      getInputByPath =
-            if path == []
+        nodeName: path:
-            then nodeName
+        if path == [ ] then
+          nodeName
         else
           getInputByPath
             # Since this could be a 'follows' input, call resolveInput.
@@ -57,16 +56,17 @@ let
           # This shadows the sourceInfo.outPath
           inherit outPath;
 
-              inherit inputs; inherit outputs; inherit sourceInfo; _type = "flake";
+          inherit inputs;
+          inherit outputs;
+          inherit sourceInfo;
+          _type = "flake";
         };
-
     in
     if node.flake or true then
       assert builtins.isFunction flake.outputs;
       result
     else
       sourceInfo
-      )
+  ) lockFile.nodes;
-      lockFile.nodes;
+in
-
+allNodes.${lockFile.root}
-in allNodes.${lockFile.root}

src/libexpr/imported-drv-to-derivation.nix

@@ -1,15 +1,20 @@
-attrs @ { drvPath, outputs, name, ... }:
+attrs@{
+  drvPath,
+  outputs,
+  name,
+  ...
+}:
 
 let
 
-  commonAttrs = (builtins.listToAttrs outputsList) //
+  commonAttrs = (builtins.listToAttrs outputsList) // {
-    { all = map (x: x.value) outputsList;
+    all = map (x: x.value) outputsList;
     inherit drvPath name;
     type = "derivation";
   };
 
-  outputToAttrListElement = outputName:
+  outputToAttrListElement = outputName: {
-    { name = outputName;
+    name = outputName;
     value = commonAttrs // {
       outPath = builtins.getAttr outputName attrs;
       inherit outputName;
@@ -17,5 +22,5 @@ let
   };
 
   outputsList = map outputToAttrListElement outputs;
-
+in
-in (builtins.head outputsList).value
+(builtins.head outputsList).value

src/libexpr/primops/derivation.nix

@@ -1,19 +1,27 @@
-/* This is the implementation of the ‘derivation’ builtin function.
+/*
-   It's actually a wrapper around the ‘derivationStrict’ primop. */
+  This is the implementation of the ‘derivation’ builtin function.
+  It's actually a wrapper around the ‘derivationStrict’ primop.
+*/
 
-drvAttrs @ { outputs ? [ "out" ], ... }:
+drvAttrs@{
+  outputs ? [ "out" ],
+  ...
+}:
 
 let
 
   strict = derivationStrict drvAttrs;
 
-  commonAttrs = drvAttrs // (builtins.listToAttrs outputsList) //
+  commonAttrs =
-    { all = map (x: x.value) outputsList;
+    drvAttrs
+    // (builtins.listToAttrs outputsList)
+    // {
+      all = map (x: x.value) outputsList;
       inherit drvAttrs;
     };
 
-  outputToAttrListElement = outputName:
+  outputToAttrListElement = outputName: {
-    { name = outputName;
+    name = outputName;
     value = commonAttrs // {
       outPath = builtins.getAttr outputName strict;
       drvPath = strict.drvPath;
@@ -23,5 +31,5 @@ let
   };
 
   outputsList = map outputToAttrListElement outputs;
-
+in
-in (builtins.head outputsList).value
+(builtins.head outputsList).value

src/nix-channel/unpack-channel.nix

@@ -1,4 +1,8 @@
-{ name, channelName, src }:
+{
+  name,
+  channelName,
+  src,
+}:
 
 derivation {
   builder = "builtin:unpack-channel";

src/nix-env/buildenv.nix

@@ -8,13 +8,15 @@ derivation {
   inherit manifest;
 
   # !!! grmbl, need structured data for passing this in a clean way.
-  derivations =
+  derivations = map (
-    map (d:
+    d:
-      [ (d.meta.active or "true")
+    [
+      (d.meta.active or "true")
       (d.meta.priority or 5)
       (builtins.length d.outputs)
-      ] ++ map (output: builtins.getAttr output d) d.outputs)
+    ]
-      derivations;
+    ++ map (output: builtins.getAttr output d) d.outputs
+  ) derivations;
 
   # Building user environments remotely just causes huge amounts of
   # network traffic, so don't do that.

treefmt.toml

@@ -1,5 +1,4 @@
-[formatter]
+[formatter.nix]
-# [formatter.nix]
+command = "nixfmt"
-# command = "nixfmt"
+includes = ["*.nix"]
-# includes = ["*.nix"]
+excludes = ["tests/**"]
-# excludes = ["tests/**"]