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

@@ -2,10 +2,15 @@ let
   inherit (builtins) concatStringsSep attrValues mapAttrs;
   inherit (import ./utils.nix) optionalString squash;
 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

@@ -2,10 +2,16 @@ let
   inherit (builtins) concatStringsSep attrValues mapAttrs;
   inherit (import ./utils.nix) optionalString squash;
 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,19 +1,39 @@
 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:
-
 let
-
   commandInfo = fromJSON commandDump;
 
-  showCommand = { command, details, filename, toplevel }:
+  showCommand =
+    {
+      command,
+      details,
+      filename,
+      toplevel,
+    }:
     let
-
       result = ''
         > **Warning** \
         > This program is
@@ -35,26 +55,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 +92,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 +106,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 +116,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 +178,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 +208,8 @@ let
             extra-experimental-features = ${experimentalFeature}
             ```
           '';
-        in ''
+        in
+        ''
           ## ${name}
 
           ${doc}
@@ -172,6 +220,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

@@ -1,9 +1,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

@@ -1,11 +1,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

@@ -1,14 +1,18 @@
 with builtins;
-
 rec {
   splitLines = s: filter (x: !isList x) (split "\n" s);
 
   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 +24,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 +37,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 +108,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,10 +31,11 @@ let
       iana-etc
       git
       openssh
-  ] ++ extraPkgs;
+    ]
-
+    ++ extraPkgs;
-  users = {
 
+  users =
+    {
       root = {
         uid = 0;
         shell = "${pkgs.bashInteractive}/bin/bash";
@@ -49,11 +53,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 +63,7 @@ let
           groups = [ "nixbld" ];
           description = "Nix build user ${toString n}";
         };
-        }
+      }) (lib.lists.range 1 32)
-      )
-      (lib.lists.range 1 32)
     );
 
   groups = {
@@ -74,24 +74,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 +97,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 +126,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 +155,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 +177,9 @@ let
                 type = "derivation";
                 meta = { };
               }
-        '') defaultPkgs)}
+            ''
+          ) defaultPkgs
+        )}
         ]
         EOF
       '';
@@ -190,7 +188,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 +198,12 @@ let
     in
     pkgs.runCommand "base-system"
       {
-        inherit passwdContents groupContents shadowContents nixConfContents;
+        inherit
+          passwdContents
+          groupContents
+          shadowContents
+          nixConfContents
+          ;
         passAsFile = [
           "passwdContents"
           "groupContents"
@@ -208,7 +212,9 @@ let
         ];
         allowSubstitutes = false;
         preferLocalBuild = true;
-      } (''
+      }
+      (
+        ''
           env
           set -x
           mkdir -p $out/etc
@@ -255,7 +261,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,11 +270,10 @@ 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 {
-
   inherit name tag maxLayers;
 
   contents = [ baseSystem ];
@@ -285,20 +291,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

@@ -14,11 +14,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;
       inherit (lib) fileset;
@@ -30,74 +39,103 @@
 
       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: { 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");
-        });
+        }
+      );
 
-      testNixVersions = pkgs: client: daemon: let
+      testNixVersions =
+        pkgs: client: daemon:
+        let
           nix = pkgs.callPackage ./package.nix {
             pname =
               "nix-tests"
-            + lib.optionalString
+              + lib.optionalString (
-            (lib.versionAtLeast daemon.version "2.4pre20211005" &&
+                lib.versionAtLeast daemon.version "2.4pre20211005"
-            lib.versionAtLeast client.version "2.4pre20211005")
+                && lib.versionAtLeast client.version "2.4pre20211005"
-            "-${client.version}-against-${daemon.version}";
+              ) "-${client.version}-against-${daemon.version}";
 
             inherit fileset;
           };
-      in nix.overrideAttrs (prevAttrs: {
+        in
+        nix.overrideAttrs (prevAttrs: {
           NIX_DAEMON_PACKAGE = daemon;
           NIX_CLIENT_PACKAGE = client;
 
@@ -113,22 +151,25 @@
             mkdir -p $out
           '';
 
-        installCheckPhase = lib.optionalString pkgs.stdenv.hostPlatform.isDarwin ''
+          installCheckPhase =
+            lib.optionalString pkgs.stdenv.hostPlatform.isDarwin ''
               export OBJC_DISABLE_INITIALIZE_FORK_SAFETY=YES
-        '' + ''
+            ''
+            + ''
               mkdir -p src/nix-channel
               make installcheck -j$NIX_BUILD_CORES -l$NIX_BUILD_CORES
             '';
         });
 
-      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}";
           }
           ''
@@ -149,25 +190,26 @@
               $(cat ${installerClosureInfo}/store-paths)
           '';
 
-      overlayFor = getStdenv: final: prev:
+      overlayFor =
+        getStdenv: final: prev:
         let
           currentStdenv = getStdenv final;
-          comDeps = with final; commonDeps {
+          comDeps =
+            with final;
+            commonDeps {
               inherit pkgs;
               inherit (currentStdenv.hostPlatform) isStatic;
             };
-        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 { };
-          boehmgc-nix = (final.boehmgc.override {
+          boehmgc-nix = (final.boehmgc.override { enableLargeConfig = true; }).overrideAttrs (o: {
-            enableLargeConfig = true;
-          }).overrideAttrs (o: {
             patches = (o.patches or [ ]) ++ [
               ./boehmgc-coroutine-sp-fallback.diff
 
@@ -207,30 +249,30 @@
             busybox-sandbox-shell = final.busybox-sandbox-shell or final.default-busybox-sandbox-shell;
           };
         };
-
+    in
-    in {
+    {
       # A Nixpkgs overlay that overrides the 'nix' and
       # 'nix.perl-bindings' packages.
       overlays.default = overlayFor (p: p.stdenv);
 
       hydraJobs = {
-
         # Binary package for various platforms.
         build = forAllSystems (system: self.packages.${system}.nix);
 
         # 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} ];
             })
         );
@@ -240,18 +282,26 @@
 
         # 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;
 
             nix = pkgs.callPackage ./package.nix {
-            inherit versionSuffix fileset officialRelease buildUnreleasedNotes;
+              inherit
+                versionSuffix
+                fileset
+                officialRelease
+                buildUnreleasedNotes
+                ;
               inherit (pkgs) build-release-notes;
               internalApiDocs = true;
               boehmgc = pkgs.boehmgc-nix;
@@ -268,13 +318,11 @@
 
         # System tests.
         tests = import ./tests/nixos { inherit lib nixpkgs nixpkgsFor; } // {
-
           # Make sure that nix-env still produces the exact same result
           # 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
@@ -282,21 +330,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 = {
@@ -333,19 +383,30 @@
               };
               treefmt = {
                 enable = true;
-              settings.formatters = [ ];
+                settings.formatters =
+                  let
+                    pkgs = nixpkgsFor.${system}.native;
+                  in
+                  [ pkgs.nixfmt ];
               };
             };
-        }) pre-commit-hooks.lib;
+          }
+        ) pre-commit-hooks.lib;
       };
 
-      checks = forAllSystems (system: let
+      checks = forAllSystems (
-        rl-next-check = name: dir:
+        system:
-          let pkgs = nixpkgsFor.${system}.native;
+        let
-          in pkgs.buildPackages.runCommand "test-${name}-release-notes" { } ''
+          rl-next-check =
+            name: dir:
+            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 {
+        in
+        {
           # FIXME(Qyriad): remove this when the migration to Meson has been completed.
           mesonBuild = self.hydraJobs.mesonBuild.${system};
           mesonBuildClang = self.hydraJobs.mesonBuildClang.${system};
@@ -355,22 +416,30 @@
           rl-next = rl-next-check "rl-next" ./doc/manual/rl-next;
           rl-next-dev = rl-next-check "rl-next-dev" ./doc/manual/rl-next-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
@@ -378,21 +447,26 @@
                   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 fileset;
@@ -400,22 +474,37 @@
                 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 =
+                    prev.buildInputs
                     ++ lib.optional (pre-commit ? enabledPackages) pre-commit.enabledPackages
-                ++ lib.optionals (stdenv.cc.isClang) [ pkgs.llvmPackages.llvm pkgs.llvmPackages.clang-unwrapped.dev ];
+                    # Unfortunately `git-hooks.nix` can't propagate `treefmt`
-              nativeBuildInputs = prev.nativeBuildInputs
+                    # formatters into `enabledPackages` correctly.
+                    ++ [ pkgs.nixfmt ]
+                    ++ lib.optionals (stdenv.cc.isClang) [
+                      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.
@@ -443,22 +532,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;
           }
         );

maintainers/build-release-notes.nix

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

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";

nix-support/nixfmt.nix

@@ -0,0 +1,79 @@
+# Copy of `nixfmt-rfc-style` vendored from `nixpkgs` master:
+# https://github.com/NixOS/nixpkgs/blob/ab6071eb54cc9b66dda436111d4f569e4e56cbf4/pkgs/by-name/ni/nixfmt-rfc-style/package.nix
+{
+  haskell,
+  haskellPackages,
+  lib,
+  fetchpatch,
+}:
+let
+  inherit (haskell.lib.compose) overrideCabal justStaticExecutables;
+
+  overrides = {
+    version = "unstable-2024-03-01";
+
+    patches = [
+      (fetchpatch {
+        url = "https://github.com/serokell/nixfmt/commit/ca9c8975ed671112fdfce94f2e9e2ad3de480c9a.patch";
+        hash = "sha256-UOSAYahSKBsqPMVcQJ3H26Eg2xpPAsNOjYMI6g+WTYU=";
+      })
+    ];
+  };
+
+  raw-pkg = haskellPackages.callPackage (
+    {
+      mkDerivation,
+      base,
+      cmdargs,
+      directory,
+      fetchzip,
+      filepath,
+      lib,
+      megaparsec,
+      mtl,
+      parser-combinators,
+      safe-exceptions,
+      scientific,
+      text,
+      transformers,
+      unix,
+    }:
+    mkDerivation {
+      pname = "nixfmt";
+      version = "0.5.0";
+      src = fetchzip {
+        url = "https://github.com/piegamesde/nixfmt/archive/2b5ee820690bae64cb4003e46917ae43541e3e0b.tar.gz";
+        sha256 = "1i1jbc1q4gd7fpilwy6s3a583yl5l8d8rlmipygj61mpclg9ihqg";
+      };
+      isLibrary = true;
+      isExecutable = true;
+      libraryHaskellDepends = [
+        base
+        megaparsec
+        mtl
+        parser-combinators
+        scientific
+        text
+        transformers
+      ];
+      executableHaskellDepends = [
+        base
+        cmdargs
+        directory
+        filepath
+        safe-exceptions
+        text
+        unix
+      ];
+      jailbreak = true;
+      homepage = "https://github.com/serokell/nixfmt";
+      description = "An opinionated formatter for Nix";
+      license = lib.licenses.mpl20;
+      mainProgram = "nixfmt";
+    }
+  ) { };
+in
+lib.pipe raw-pkg [
+  (overrideCabal overrides)
+  justStaticExecutables
+]

package.nix

@@ -40,9 +40,11 @@
   util-linuxMinimal ? utillinuxMinimal,
   utillinuxMinimal ? null,
   xz,
-
   busybox-sandbox-shell,
 
+  # Customization options
+  # =====================
+
   pname ? "nix",
   versionSuffix ? "",
   officialRelease ? true,
@@ -61,19 +63,21 @@
   __forDefaults ? {
     canRunInstalled = stdenv.buildPlatform.canExecute stdenv.hostPlatform;
   },
-}: let
+}:
+let
   inherit (__forDefaults) canRunInstalled;
 
   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.
@@ -95,34 +99,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
@@ -130,13 +140,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;
 
@@ -148,15 +164,19 @@ 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
-  ] ++ [
+    ]
+    ++ [
       (lib.getBin lowdown)
       mdbook
       mdbook-linkcheck
       autoconf-archive
-  ] ++ lib.optional (!buildWithMeson) autoreconfHook ++ [
+    ]
+    ++ lib.optional (!buildWithMeson) autoreconfHook
+    ++ [
       pkg-config
 
       # Tests
@@ -164,7 +184,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 [
@@ -173,7 +194,8 @@ in stdenv.mkDerivation (finalAttrs: {
       cmake
     ];
 
-  buildInputs = [
+  buildInputs =
+    [
       curl
       bzip2
       xz
@@ -187,12 +209,14 @@ in stdenv.mkDerivation (finalAttrs: {
       libsodium
       toml11
     ]
-    ++ 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
@@ -201,9 +225,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.
@@ -212,23 +234,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"
@@ -237,20 +263,20 @@ in stdenv.mkDerivation (finalAttrs: {
       fi
     '';
 
-  configureFlags = lib.optionals stdenv.isLinux [
+  configureFlags =
+    lib.optionals stdenv.isLinux [
       "--with-boost=${boost}/lib"
       "--with-sandbox-shell=${busybox-sandbox-shell}/bin/busybox"
-  ] ++ lib.optionals (stdenv.isLinux && !(stdenv.hostPlatform.isStatic && stdenv.system == "aarch64-linux")) [
-    "LDFLAGS=-fuse-ld=gold"
     ]
+    ++ lib.optionals (
+      stdenv.isLinux && !(stdenv.hostPlatform.isStatic && stdenv.system == "aarch64-linux")
+    ) [ "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";
 
@@ -262,26 +288,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"
     '';
@@ -290,9 +318,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
@@ -310,12 +336,9 @@ 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; };
-    inherit fileset stdenv;
-  };
 })

perl/default.nix

@@ -1,11 +1,22 @@
-{ lib, fileset
+{
-, stdenv
+  lib,
-, perl, perlPackages
+  fileset,
-, autoconf-archive, autoreconfHook, pkg-config
+  stdenv,
-, nix, curl, bzip2, xz, boost, libsodium, darwin
+  perl,
+  perlPackages,
+  autoconf-archive,
+  autoreconfHook,
+  pkg-config,
+  nix,
+  curl,
+  bzip2,
+  xz,
+  boost,
+  libsodium,
+  darwin,
 }:
-
+perl.pkgs.toPerlModule (
-perl.pkgs.toPerlModule (stdenv.mkDerivation {
+  stdenv.mkDerivation {
     name = "nix-perl-${nix.version}";
 
     src = fileset.toSource {
@@ -23,14 +34,15 @@ perl.pkgs.toPerlModule (stdenv.mkDerivation {
       ];
     };
 
-  nativeBuildInputs =
+    nativeBuildInputs = [
-    [ autoconf-archive
+      autoconf-archive
       autoreconfHook
       pkg-config
     ];
 
     buildInputs =
-    [ nix
+      [
+        nix
         curl
         bzip2
         xz
@@ -48,4 +60,5 @@ perl.pkgs.toPerlModule (stdenv.mkDerivation {
     enableParallelBuilding = true;
 
     postUnpack = "sourceRoot=$sourceRoot/perl";
-})
+  }
+)

src/libexpr/fetchurl.nix

@@ -1,27 +1,52 @@
-{ 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
-, executable ? false
+      hash
-, unpack ? false
+    else if sha512 != "" then
-, name ? baseNameOf (toString url)
+      sha512
-, impure ? false
+    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,
+  unpack ? false,
+  name ? baseNameOf (toString url),
+  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 +58,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

@@ -1,18 +1,15 @@
 lockFileStr: rootSrc: rootSubdir:
-
 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 +17,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 +53,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,18 @@
-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 +20,5 @@ let
   };
 
   outputsList = map outputToAttrListElement outputs;
-
+in
-in (builtins.head outputsList).value
+(builtins.head outputsList).value

src/libexpr/primops/derivation.nix

@@ -1,19 +1,24 @@
-/* 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 +28,5 @@ let
   };
 
   outputsList = map outputToAttrListElement outputs;
-
+in
-in (builtins.head outputsList).value
+(builtins.head outputsList).value

src/nix-channel/unpack-channel.nix

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

src/nix-env/buildenv.nix

@@ -1,5 +1,4 @@
 { derivations, manifest }:
-
 derivation {
   name = "user-environment";
   system = "builtin";
@@ -8,13 +7,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.

tests/functional/lang/parse-fail-eol-1.err.exp

@@ -1,5 +1,5 @@
 error: undefined variable 'invalid'
-       at /pwd/lang/eval-fail-eol-1.nix:2:1:
+       at «stdin»:2:1:
             1| # foo
             2| invalid
              | ^

tests/functional/lang/parse-fail-eol-2.err.exp

@@ -1,5 +1,5 @@
 error: undefined variable 'invalid'
-       at /pwd/lang/eval-fail-eol-2.nix:2:1:
+       at «stdin»:2:1:
             1| # foo
             2| invalid
              | ^

tests/functional/lang/parse-fail-eol-3.err.exp

@@ -1,5 +1,5 @@
 error: undefined variable 'invalid'
-       at /pwd/lang/eval-fail-eol-3.nix:2:1:
+       at «stdin»:2:1:
             1| # foo
             2| invalid
              | ^

tests/functional/lang/parse-fail-path-slash.err.exp

@@ -1,5 +1,5 @@
 error: path has a trailing slash
-       at /pwd/lang/eval-fail-path-slash.nix:6:12:
+       at «stdin»:6:12:
             5| # and https://nixos.org/nix-dev/2016-June/020829.html
             6| /nix/store/
              |            ^

tests/functional/lang/parse-fail-set.err.exp

@@ -1,5 +1,5 @@
 error: undefined variable 'x'
-       at /pwd/lang/eval-fail-set.nix:1:3:
+       at «stdin»:1:3:
             1| 8.x
              |   ^
             2|

treefmt.toml

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