Format .nix files

... with nixfmt (rfc style)

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-builtins.nix

@@ -5,7 +5,15 @@ in
 
 builtinsInfo:
 let
-  showBuiltin = name: { doc, type ? null, args ? [ ], experimental-feature ? null, impure-only ? false }:
+  showBuiltin =
+    name:
+    {
+      doc,
+      type ? null,
+      args ? [ ],
+      experimental-feature ? null,
+      impure-only ? false,
+    }:
     let
       type' = optionalString (type != null) " (${type})";
 

doc/manual/generate-manpage.nix

@@ -32,7 +32,13 @@ let
 
   commandInfo = fromJSON commandDump;
 
-  showCommand = { command, details, filename, toplevel }:
+  showCommand =
+    {
+      command,
+      details,
+      filename,
+      toplevel,
+    }:
     let
 
       result = ''
@@ -56,26 +62,27 @@ let
         ${maybeOptions}
       '';
 
-      showSynopsis = command: args:
+      showSynopsis =
+        command: args:
         let
           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);
 
@@ -99,38 +106,39 @@ let
 
             ${allStores}
           '';
-          index = replaceStrings
+          index =
+            replaceStrings
               [ "@store-types@" "./local-store.md" "./local-daemon-store.md" ]
               [ storesOverview "#local-store" "#local-daemon-store" ]
               details.doc;
           storesOverview =
             let
-              showEntry = store:
+              showEntry = store: "- [${store.name}](#${store.slug})";
-                "- [${store.name}](#${store.slug})";
             in
             concatStringsSep "\n" (map showEntry storesList) + "\n";
           allStores = concatStringsSep "\n" (attrValues storePages);
-          storePages = listToAttrs
+          storePages = listToAttrs (
-            (map (s: { name = s.filename; value = s.page; }) storesList);
+            map (s: {
+              name = s.filename;
+              value = s.page;
+            }) storesList
+          );
           storesList = showStoreDocs {
             storeInfo = commandInfo.stores;
             inherit inlineHTML;
           };
-          hasInfix = infix: content:
+          hasInfix =
+            infix: content:
             builtins.stringLength content != builtins.stringLength (replaceStrings [ infix ] [ "" ] content);
         in
         optionalString (details ? doc) (
           # An alternate implementation with builtins.match stack overflowed on some systems.
-          if hasInfix "@store-types@" details.doc
+          if hasInfix "@store-types@" details.doc then help-stores else details.doc
-          then help-stores
-          else details.doc
         );
 
       maybeOptions =
         let
-          allVisibleOptions = filterAttrs
+          allVisibleOptions = filterAttrs (_: o: !o.hiddenCategory) (details.flags // toplevel.flags);
-            (_: o: ! o.hiddenCategory)
-            (details.flags // toplevel.flags);
         in
         optionalString (allVisibleOptions != { }) ''
           # Options
@@ -142,55 +150,73 @@ let
           > See [`man nix.conf`](@docroot@/command-ref/conf-file.md#command-line-flags) for overriding configuration settings with command line flags.
         '';
 
-      showOptions = inlineHTML: allOptions:
+      showOptions =
+        inlineHTML: allOptions:
         let
           showCategory = cat: opts: ''
             ${optionalString (cat != "") "## ${cat}"}
 
             ${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 =
-          categories = mapAttrs
+            mapAttrs
               # Convert each group from a list of key-value pairs back to an attrset
               (_: listToAttrs)
-            (groupBy
+              (groupBy (cmd: cmd.value.category) (attrsToList allOptions));
-              (cmd: cmd.value.category)
+        in
-              (attrsToList allOptions));
+        concatStrings (attrValues (mapAttrs showCategory categories));
-        in concatStrings (attrValues (mapAttrs showCategory categories));
+    in
-    in squash result;
+    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";
@@ -199,9 +225,11 @@ 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";
 
-in (listToAttrs manpages) // { "SUMMARY.md" = tableOfContents; }
+in
+(listToAttrs manpages) // { "SUMMARY.md" = tableOfContents; }

doc/manual/generate-settings.nix

@@ -1,23 +1,49 @@
 let
-  inherit (builtins) attrValues concatStringsSep isAttrs isBool mapAttrs;
+  inherit (builtins)
-  inherit (import <nix/utils.nix>) concatStrings indent optionalString squash;
+    attrValues
+    concatStringsSep
+    isAttrs
+    isBool
+    mapAttrs
+    ;
+  inherit (import <nix/utils.nix>)
+    concatStrings
+    indent
+    optionalString
+    squash
+    ;
 in
 
 # `inlineHTML` is a hack to accommodate inconsistent output from `lowdown`
-{ prefix, inlineHTML ? true }: settingsInfo:
+{
+  prefix,
+  inlineHTML ? true,
+}:
+settingsInfo:
 
 let
 
-  showSetting = prefix: setting: { description, documentDefault, defaultValue, aliases, value, experimentalFeature }:
+  showSetting =
+    prefix: setting:
+    {
+      description,
+      documentDefault,
+      defaultValue,
+      aliases,
+      value,
+      experimentalFeature,
+    }:
     let
       result = squash ''
         - ${item}
 
         ${indent "  " body}
       '';
-      item = if inlineHTML
+      item =
-        then ''<span id="${prefix}-${setting}">[`${setting}`](#${prefix}-${setting})</span>''
+        if inlineHTML then
-        else "`${setting}`";
+          ''<span id="${prefix}-${setting}">[`${setting}`](#${prefix}-${setting})</span>''
+        else
+          "`${setting}`";
       # separate body to cleanly handle indentation
       body = ''
         ${experimentalFeatureNote}
@@ -46,22 +72,28 @@ let
         > ```
       '';
 
-      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 =
+        aliases:
         optionalString (aliases != [ ])
           "**Deprecated alias:** ${(concatStringsSep ", " (map (s: "`${s}`") aliases))}";
 
-    in result;
+    in
+    result;
 
-in concatStrings (attrValues (mapAttrs (showSetting prefix) settingsInfo))
+in
+concatStrings (attrValues (mapAttrs (showSetting prefix) settingsInfo))

doc/manual/generate-store-info.nix

@@ -1,6 +1,20 @@
 let
-  inherit (builtins) attrNames listToAttrs concatStringsSep readFile replaceStrings;
+  inherit (builtins)
-  inherit (import <nix/utils.nix>) optionalString filterAttrs trim squash toLower unique indent;
+    attrNames
+    listToAttrs
+    concatStringsSep
+    readFile
+    replaceStrings
+    ;
+  inherit (import <nix/utils.nix>)
+    optionalString
+    filterAttrs
+    trim
+    squash
+    toLower
+    unique
+    indent
+    ;
   showSettings = import <nix/generate-settings.nix>;
 in
 
@@ -14,7 +28,13 @@ in
 
 let
 
-  showStore = { name, slug }: { settings, doc, experimentalFeature }:
+  showStore =
+    { name, slug }:
+    {
+      settings,
+      doc,
+      experimentalFeature,
+    }:
     let
       result = squash ''
         # ${name}
@@ -25,7 +45,10 @@ let
 
         ## Settings
 
-        ${showSettings { prefix = "store-${slug}"; inherit inlineHTML; } settings}
+        ${showSettings {
+          prefix = "store-${slug}";
+          inherit inlineHTML;
+        } settings}
       '';
 
       experimentalFeatureNote = optionalString (experimentalFeature != null) ''
@@ -43,15 +66,15 @@ let
         > extra-experimental-features = ${experimentalFeature}
         > ```
       '';
-    in result;
+    in
+    result;
 
-  storesList = map
+  storesList = map (name: rec {
-    (name: rec {
     inherit name;
     slug = replaceStrings [ " " ] [ "-" ] (toLower name);
     filename = "${slug}.md";
     page = showStore { inherit name slug; } storeInfo.${name};
-    })
+  }) (attrNames storeInfo);
-    (attrNames storeInfo);
 
-in storesList
+in
+storesList

doc/manual/generate-store-types.nix

@@ -1,5 +1,11 @@
 let
-  inherit (builtins) attrNames listToAttrs concatStringsSep readFile replaceStrings;
+  inherit (builtins)
+    attrNames
+    listToAttrs
+    concatStringsSep
+    readFile
+    replaceStrings
+    ;
   showSettings = import <nix/generate-settings.nix>;
   showStoreDocs = import <nix/generate-store-info.nix>;
 in
@@ -14,26 +20,28 @@ let
 
   index =
     let
-      showEntry = store:
+      showEntry = store: "- [${store.name}](./${store.filename})";
-        "- [${store.name}](./${store.filename})";
     in
     concatStringsSep "\n" (map showEntry storesList);
 
-  "index.md" = replaceStrings
+  "index.md" =
-    [ "@store-types@" ] [ index ]
+    replaceStrings [ "@store-types@" ] [ index ]
       (readFile ./source/store/types/index.md.in);
 
   tableOfContents =
     let
-      showEntry = store:
+      showEntry = store: "    - [${store.name}](store/types/${store.filename})";
-        "    - [${store.name}](store/types/${store.filename})";
     in
     concatStringsSep "\n" (map showEntry storesList) + "\n";
 
   "SUMMARY.md" = tableOfContents;
 
-  storePages = listToAttrs
+  storePages = listToAttrs (
-    (map (s: { name = s.filename; value = s.page; }) storesList);
+    map (s: {
+      name = s.filename;
+      value = s.page;
+    }) storesList
+  );
 
 in
 storePages // { inherit "index.md" "SUMMARY.md"; }

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

@@ -2,8 +2,8 @@ with builtins;
 with import <nix/utils.nix>;
 
 let
-  showExperimentalFeature = name: doc:
+  showExperimentalFeature = name: doc: ''
-    ''
     - [`${name}`](@docroot@/development/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,7 +2,8 @@ with builtins;
 with import <nix/utils.nix>;
 
 let
-  showExperimentalFeature = name: doc:
+  showExperimentalFeature =
+    name: doc:
     squash ''
       ## [`${name}`]{#xp-feature-${name}}
 

doc/manual/package.nix

@@ -1,19 +1,20 @@
-{ lib
+{
-, mkMesonDerivation
+  lib,
+  mkMesonDerivation,
 
-, meson
+  meson,
-, ninja
+  ninja,
-, lowdown-unsandboxed
+  lowdown-unsandboxed,
-, mdbook
+  mdbook,
-, mdbook-linkcheck
+  mdbook-linkcheck,
-, jq
+  jq,
-, python3
+  python3,
-, rsync
+  rsync,
-, nix-cli
+  nix-cli,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -25,7 +26,8 @@ mkMesonDerivation (finalAttrs: {
   inherit version;
 
   workDir = ./.;
-  fileset = fileset.difference
+  fileset =
+    fileset.difference
       (fileset.unions [
         ../../.version
         # Too many different types of files to filter for now
@@ -36,7 +38,10 @@ mkMesonDerivation (finalAttrs: {
       ../../doc/manual/package.nix;
 
   # TODO the man pages should probably be separate
-  outputs = [ "out" "man" ];
+  outputs = [
+    "out"
+    "man"
+  ];
 
   # Hack for sake of the dev shell
   passthru.externalNativeBuildInputs = [
@@ -54,8 +59,7 @@ mkMesonDerivation (finalAttrs: {
     nix-cli
   ];
 
-  preConfigure =
+  preConfigure = ''
-    ''
     chmod u+w ./.version
     echo ${finalAttrs.version} > ./.version
   '';

doc/manual/utils.nix

@@ -11,10 +11,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"
@@ -28,10 +33,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;
@@ -39,19 +46,30 @@ 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 ]) [ ];
 
   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 "";
 
-  indent = prefix: s:
+  indent =
-    concatStringsSep "\n" (map (x: if x == "" then x else "${prefix}${x}") (splitLines s));
+    prefix: s: concatStringsSep "\n" (map (x: if x == "" then x else "${prefix}${x}") (splitLines s));
 }

docker.nix

@@ -1,21 +1,24 @@
-{ 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 ? { },
-, uid ? 0
+  flake-registry ? null,
-, gid ? 0
+  uid ? 0,
-, uname ? "root"
+  gid ? 0,
-, gname ? "root"
+  uname ? "root",
+  gname ? "root",
 }:
 let
-  defaultPkgs = with pkgs; [
+  defaultPkgs =
+    with pkgs;
+    [
       nix
       bashInteractive
       coreutils-full
@@ -32,9 +35,11 @@ let
       iana-etc
       git
       openssh
-  ] ++ extraPkgs;
+    ]
+    ++ extraPkgs;
 
-  users = {
+  users =
+    {
 
       root = {
         uid = 0;
@@ -54,7 +59,8 @@ let
         description = "Unprivileged account (don't use!)";
       };
 
-  } // lib.optionalAttrs (uid != 0) {
+    }
+    // lib.optionalAttrs (uid != 0) {
       "${uname}" = {
         uid = uid;
         shell = "${pkgs.bashInteractive}/bin/bash";
@@ -63,10 +69,9 @@ let
         groups = [ "${gname}" ];
         description = "Nix user";
       };
-  } // lib.listToAttrs (
+    }
-    map
+    // lib.listToAttrs (
-      (
+      map (n: {
-        n: {
         name = "nixbld${toString n}";
         value = {
           uid = 30000 + n;
@@ -74,39 +79,35 @@ let
           groups = [ "nixbld" ];
           description = "Nix build user ${toString n}";
         };
-        }
+      }) (lib.lists.range 1 32)
-      )
-      (lib.lists.range 1 32)
     );
 
-  groups = {
+  groups =
+    {
       root.gid = 0;
       nixbld.gid = 30000;
       nobody.gid = 65534;
-  } // lib.optionalAttrs (gid != 0) {
+    }
+    // lib.optionalAttrs (gid != 0) {
       "${gname}".gid = gid;
     };
 
   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
   # {
@@ -116,42 +117,35 @@ 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
-                (group: {
+          ++ map (group: {
             inherit user group;
-                })
+          }) groups
-                groups
+        ) [ ] (lib.attrNames users)
-          )
-          [ ]
-          (lib.attrNames users)
       );
     in
-    (
+    (builtins.foldl' (
-      builtins.foldl'
+      acc: v:
-        (
+      acc
-          acc: v: acc // {
+      // {
         ${v.group} = acc.${v.group} or [ ] ++ [ v.user ];
       }
-        )
+    ) { } mappings)
-        { }
-        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";
@@ -159,11 +153,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";
 
   userHome = if uid == 0 then "/root" else "/home/${uname}";
 
@@ -184,13 +184,19 @@ 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}";
@@ -198,7 +204,9 @@ let
                 type = "derivation";
                 meta = { };
               }
-        '') defaultPkgs)}
+            ''
+          ) defaultPkgs
+        )}
         ]
         EOF
       '';
@@ -207,7 +215,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"
@@ -216,7 +225,12 @@ let
     in
     pkgs.runCommand "base-system"
       {
-        inherit passwdContents groupContents shadowContents nixConfContents;
+        inherit
+          passwdContents
+          groupContents
+          shadowContents
+          nixConfContents
+          ;
         passAsFile = [
           "passwdContents"
           "groupContents"
@@ -225,7 +239,9 @@ let
         ];
         allowSubstitutes = false;
         preferLocalBuild = true;
-      } (''
+      }
+      (
+        ''
           env
           set -x
           mkdir -p $out/etc
@@ -272,7 +288,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="${userHome}/.cache/nix"
           mkdir -p $out$nixCacheDir
           globalFlakeRegistryPath="$nixCacheDir/flake-registry.json"
@@ -280,12 +297,21 @@ 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 uid gid uname gname;
+  inherit
+    name
+    tag
+    maxLayers
+    uid
+    gid
+    uname
+    gname
+    ;
 
   contents = [ baseSystem ];
 
@@ -305,15 +331,19 @@ pkgs.dockerTools.buildLayeredImageWithNixDb {
     User = "${toString uid}:${toString gid}";
     Env = [
       "USER=${uname}"
-      "PATH=${lib.concatStringsSep ":" [
+      "PATH=${
+        lib.concatStringsSep ":" [
           "${userHome}/.nix-profile/bin"
           "/nix/var/nix/profiles/default/bin"
           "/nix/var/nix/profiles/default/sbin"
-      ]}"
+        ]
-      "MANPATH=${lib.concatStringsSep ":" [
+      }"
+      "MANPATH=${
+        lib.concatStringsSep ":" [
           "${userHome}/.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"

flake.nix

@@ -5,7 +5,10 @@
 
   inputs.nixpkgs-regression.url = "github:NixOS/nixpkgs/215d4d0fd80ca5163643b03a33fde804a29cc1e2";
   inputs.nixpkgs-23-11.url = "github:NixOS/nixpkgs/a62e6edd6d5e1fa0329b8653c801147986f8d446";
-  inputs.flake-compat = { url = "github:edolstra/flake-compat"; flake = false; };
+  inputs.flake-compat = {
+    url = "github:edolstra/flake-compat";
+    flake = false;
+  };
 
   # dev tooling
   inputs.flake-parts.url = "github:hercules-ci/flake-parts";
@@ -19,8 +22,13 @@
   inputs.git-hooks-nix.inputs.gitignore.follows = "";
   inputs.nixfmt.url = "github:NixOS/nixfmt";
 
-  outputs = inputs@{ self, nixpkgs, nixpkgs-regression, ... }:
+  outputs =
-
+    inputs@{
+      self,
+      nixpkgs,
+      nixpkgs-regression,
+      ...
+    }:
 
     let
       inherit (nixpkgs) lib;
@@ -28,9 +36,15 @@
       officialRelease = false;
 
       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 = [
@@ -69,44 +83,57 @@
 
       forAllStdenvs = lib.genAttrs stdenvs;
 
-
       # We don't apply flake-parts to the whole flake so that non-development attributes
       # load without fetching any development inputs.
       devFlake = inputs.flake-parts.lib.mkFlake { inherit inputs; } {
         imports = [ ./maintainers/flake-module.nix ];
         systems = lib.subtractLists crossSystems systems;
-        perSystem = { system, ... }: {
+        perSystem =
+          { system, ... }:
+          {
             _module.args.pkgs = nixpkgsFor.${system}.native;
           };
       };
 
       # Memoize nixpkgs for different platforms for efficiency.
-      nixpkgsFor = forAllSystems
+      nixpkgsFor = forAllSystems (
-        (system: let
+        system:
-          make-pkgs = crossSystem:
+        let
-            forAllStdenvs (stdenv: import nixpkgs {
+          make-pkgs =
+            crossSystem:
+            forAllStdenvs (
+              stdenv:
+              import nixpkgs {
                 localSystem = {
                   inherit system;
                 };
-              crossSystem = if crossSystem == null then null else {
+                crossSystem =
+                  if crossSystem == null then
+                    null
+                  else
+                    {
                       config = crossSystem;
-              } // lib.optionalAttrs (crossSystem == "x86_64-unknown-freebsd13") {
+                    }
+                    // lib.optionalAttrs (crossSystem == "x86_64-unknown-freebsd13") {
                       useLLVM = true;
                     };
                 overlays = [
                   (overlayFor (pkgs: pkgs.${stdenv}))
                 ];
-            });
+              }
-        in rec {
+            );
+        in
+        rec {
           nativeForStdenv = make-pkgs null;
           crossForStdenv = forAllCrossSystems make-pkgs;
           # Alias for convenience
           native = nativeForStdenv.stdenv;
-          cross = forAllCrossSystems (crossSystem:
+          cross = forAllCrossSystems (crossSystem: crossForStdenv.${crossSystem}.stdenv);
-            crossForStdenv.${crossSystem}.stdenv);
+        }
-        });
+      );
 
-      overlayFor = getStdenv: final: prev:
+      overlayFor =
+        getStdenv: final: prev:
         let
           stdenv = getStdenv final;
         in
@@ -153,12 +180,19 @@
           # See https://github.com/NixOS/nixpkgs/pull/214409
           # Remove when fixed in this flake's nixpkgs
           pre-commit =
-            if prev.stdenv.hostPlatform.system == "i686-linux"
+            if prev.stdenv.hostPlatform.system == "i686-linux" then
-            then (prev.pre-commit.override (o: { dotnet-sdk = ""; })).overridePythonAttrs (o: { doCheck = false; })
+              (prev.pre-commit.override (o: {
-            else prev.pre-commit;
+                dotnet-sdk = "";
+              })).overridePythonAttrs
+                (o: {
+                  doCheck = false;
+                })
+            else
+              prev.pre-commit;
         };
 
-    in {
+    in
+    {
       # A Nixpkgs overlay that overrides the 'nix' and
       # 'nix-perl-bindings' packages.
       overlays.default = overlayFor (p: p.stdenv);
@@ -176,40 +210,53 @@
           ;
       };
 
-      checks = forAllSystems (system: {
+      checks = forAllSystems (
+        system:
+        {
           installerScriptForGHA = self.hydraJobs.installerScriptForGHA.${system};
           installTests = self.hydraJobs.installTests.${system};
           nixpkgsLibTests = self.hydraJobs.tests.nixpkgsLibTests.${system};
           rl-next =
-          let pkgs = nixpkgsFor.${system}.native;
+            let
-          in pkgs.buildPackages.runCommand "test-rl-next-release-notes" { } ''
+              pkgs = nixpkgsFor.${system}.native;
+            in
+            pkgs.buildPackages.runCommand "test-rl-next-release-notes" { } ''
               LANG=C.UTF-8 ${pkgs.changelog-d}/bin/changelog-d ${./doc/manual/rl-next} >$out
             '';
           repl-completion = nixpkgsFor.${system}.native.callPackage ./tests/repl-completion.nix { };
-      } // (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
+        }
+        // (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
           dockerImage = self.hydraJobs.dockerImage.${system};
-      } // (lib.optionalAttrs (!(builtins.elem system linux32BitSystems))) {
+        }
+        // (lib.optionalAttrs (!(builtins.elem system linux32BitSystems))) {
           # Some perl dependencies are broken on i686-linux.
           # Since the support is only best-effort there, disable the perl
           # bindings
           perlBindings = self.hydraJobs.perlBindings.${system};
         }
         # Add "passthru" tests
-      // flatMapAttrs ({
+        //
+          flatMapAttrs
+            (
+              {
                 "" = nixpkgsFor.${system}.native;
-        } // lib.optionalAttrs (! nixpkgsFor.${system}.native.stdenv.hostPlatform.isDarwin) {
+              }
+              // lib.optionalAttrs (!nixpkgsFor.${system}.native.stdenv.hostPlatform.isDarwin) {
                 # TODO: enable static builds for darwin, blocked on:
                 #       https://github.com/NixOS/nixpkgs/issues/320448
                 # TODO: disabled to speed up GHA CI.
                 #"static-" = nixpkgsFor.${system}.native.pkgsStatic;
-        })
+              }
-        (nixpkgsPrefix: nixpkgs:
+            )
-          flatMapAttrs nixpkgs.nixComponents
+            (
-            (pkgName: pkg:
+              nixpkgsPrefix: nixpkgs:
-              flatMapAttrs pkg.tests or {}
+              flatMapAttrs nixpkgs.nixComponents (
-              (testName: test: {
+                pkgName: pkg:
+                flatMapAttrs pkg.tests or { } (
+                  testName: test: {
                     "${nixpkgsPrefix}${pkgName}-${testName}" = test;
-              })
+                  }
+                )
               )
               // lib.optionalAttrs (nixpkgs.stdenv.hostPlatform == nixpkgs.stdenv.buildPlatform) {
                 "${nixpkgsPrefix}nix-functional-tests" = nixpkgs.nixComponents.nix-functional-tests;
@@ -218,11 +265,14 @@
         // devFlake.checks.${system} or { }
       );
 
-      packages = forAllSystems (system:
+      packages = forAllSystems (
-        { # Here we put attributes that map 1:1 into packages.<system>, ie
+        system:
+        {
+          # Here we put attributes that map 1:1 into packages.<system>, ie
           # for which we don't apply the full build matrix such as cross or static.
           inherit (nixpkgsFor.${system}.native)
-            changelog-d;
+            changelog-d
+            ;
           default = self.packages.${system}.nix;
           installerScriptForGHA = self.hydraJobs.installerScriptForGHA.${system};
           binaryTarball = self.hydraJobs.binaryTarball.${system};
@@ -233,8 +283,10 @@
           nix-external-api-docs = nixpkgsFor.${system}.native.nixComponents.nix-external-api-docs;
         }
         # We need to flatten recursive attribute sets of derivations to pass `flake check`.
-        // flatMapAttrs
+        //
-          { # Components we'll iterate over in the upcoming lambda
+          flatMapAttrs
+            {
+              # Components we'll iterate over in the upcoming lambda
               "nix-util" = { };
               "nix-util-c" = { };
               "nix-util-test-support" = { };
@@ -265,33 +317,55 @@
 
               "nix-everything" = { };
 
-            "nix-functional-tests" = { supportsCross = false; };
+              "nix-functional-tests" = {
+                supportsCross = false;
+              };
 
-            "nix-perl-bindings" = { supportsCross = false; };
+              "nix-perl-bindings" = {
+                supportsCross = false;
+              };
             }
-          (pkgName: { supportsCross ? true }: {
+            (
+              pkgName:
+              {
+                supportsCross ? true,
+              }:
+              {
                 # These attributes go right into `packages.<system>`.
                 "${pkgName}" = nixpkgsFor.${system}.native.nixComponents.${pkgName};
                 "${pkgName}-static" = nixpkgsFor.${system}.native.pkgsStatic.nixComponents.${pkgName};
                 "${pkgName}-llvm" = nixpkgsFor.${system}.native.pkgsLLVM.nixComponents.${pkgName};
               }
-            // lib.optionalAttrs supportsCross (flatMapAttrs (lib.genAttrs crossSystems (_: { })) (crossSystem: {}: {
+              // lib.optionalAttrs supportsCross (
+                flatMapAttrs (lib.genAttrs crossSystems (_: { })) (
+                  crossSystem:
+                  { }:
+                  {
                     # These attributes go right into `packages.<system>`.
                     "${pkgName}-${crossSystem}" = nixpkgsFor.${system}.cross.${crossSystem}.nixComponents.${pkgName};
-            }))
+                  }
-            // flatMapAttrs (lib.genAttrs stdenvs (_: { })) (stdenvName: {}: {
+                )
+              )
+              // flatMapAttrs (lib.genAttrs stdenvs (_: { })) (
+                stdenvName:
+                { }:
+                {
                   # These attributes go right into `packages.<system>`.
-              "${pkgName}-${stdenvName}" = nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.nixComponents.${pkgName};
+                  "${pkgName}-${stdenvName}" =
-            })
+                    nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.nixComponents.${pkgName};
+                }
+              )
             )
         // lib.optionalAttrs (builtins.elem system linux64BitSystems) {
           dockerImage =
             let
               pkgs = nixpkgsFor.${system}.native;
-            image = import ./docker.nix { inherit pkgs; tag = pkgs.nix.version; };
+              image = import ./docker.nix {
+                inherit pkgs;
+                tag = pkgs.nix.version;
+              };
             in
-          pkgs.runCommand
+            pkgs.runCommand "docker-image-tarball-${pkgs.nix.version}"
-            "docker-image-tarball-${pkgs.nix.version}"
               { meta.description = "Docker image with Nix for ${system}"; }
               ''
                 mkdir -p $out/nix-support
@@ -299,28 +373,51 @@
                 ln -s ${image} $image
                 echo "file binary-dist $image" >> $out/nix-support/hydra-build-products
               '';
-      });
+        }
+      );
 
-      devShells = let
+      devShells =
+        let
           makeShell = import ./packaging/dev-shell.nix { inherit inputs lib devFlake; };
           prefixAttrs = prefix: lib.concatMapAttrs (k: v: { "${prefix}-${k}" = v; });
         in
-        forAllSystems (system:
+        forAllSystems (
-          prefixAttrs "native" (forAllStdenvs (stdenvName: makeShell {
+          system:
+          prefixAttrs "native" (
+            forAllStdenvs (
+              stdenvName:
+              makeShell {
                 pkgs = nixpkgsFor.${system}.nativeForStdenv.${stdenvName};
-          })) //
+              }
-          lib.optionalAttrs (!nixpkgsFor.${system}.native.stdenv.isDarwin) (
+            )
-            prefixAttrs "static" (forAllStdenvs (stdenvName: makeShell {
+          )
+          // lib.optionalAttrs (!nixpkgsFor.${system}.native.stdenv.isDarwin) (
+            prefixAttrs "static" (
+              forAllStdenvs (
+                stdenvName:
+                makeShell {
                   pkgs = nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.pkgsStatic;
-            })) //
+                }
-            prefixAttrs "llvm" (forAllStdenvs (stdenvName: makeShell {
+              )
+            )
+            // prefixAttrs "llvm" (
+              forAllStdenvs (
+                stdenvName:
+                makeShell {
                   pkgs = nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.pkgsLLVM;
-            })) //
+                }
-            prefixAttrs "cross" (forAllCrossSystems (crossSystem: makeShell {
+              )
+            )
+            // prefixAttrs "cross" (
+              forAllCrossSystems (
+                crossSystem:
+                makeShell {
                   pkgs = nixpkgsFor.${system}.cross.${crossSystem};
-            }))
+                }
-          ) //
+              )
-          {
+            )
+          )
+          // {
             native = self.devShells.${system}.native-stdenv;
             default = self.devShells.${system}.native;
           }

maintainers/flake-module.nix

@@ -1,11 +1,18 @@
-{ lib, getSystem, inputs, ... }:
+{
+  lib,
+  getSystem,
+  inputs,
+  ...
+}:
 
 {
   imports = [
     inputs.git-hooks-nix.flakeModule
   ];
 
-  perSystem = { config, pkgs, ... }: {
+  perSystem =
+    { config, pkgs, ... }:
+    {
 
       # https://flake.parts/options/git-hooks-nix#options
       pre-commit.settings = {

packaging/binary-tarball.nix

@@ -1,14 +1,18 @@
-{ runCommand
+{
-, system
+  runCommand,
-, buildPackages
+  system,
-, cacert
+  buildPackages,
-, nix
+  cacert,
+  nix,
 }:
 
 let
 
   installerClosureInfo = buildPackages.closureInfo {
-    rootPaths = [ nix cacert ];
+    rootPaths = [
+      nix
+      cacert
+    ];
   };
 
   inherit (nix) version;

packaging/components.nix

@@ -13,9 +13,11 @@ let
 
   versionSuffix = lib.optionalString (!officialRelease) "pre";
 
-  fineVersionSuffix = lib.optionalString
+  fineVersionSuffix =
-    (!officialRelease)
+    lib.optionalString (!officialRelease)
-    "pre${builtins.substring 0 8 (src.lastModifiedDate or src.lastModified or "19700101")}_${src.shortRev or "dirty"}";
+      "pre${
+        builtins.substring 0 8 (src.lastModifiedDate or src.lastModified or "19700101")
+      }_${src.shortRev or "dirty"}";
 
   fineVersion = baseVersion + fineVersionSuffix;
 in
@@ -54,7 +56,9 @@ in
 
   nix-cli = callPackage ../src/nix/package.nix { version = fineVersion; };
 
-  nix-functional-tests = callPackage ../src/nix-functional-tests/package.nix { version = fineVersion; };
+  nix-functional-tests = callPackage ../src/nix-functional-tests/package.nix {
+    version = fineVersion;
+  };
 
   nix-manual = callPackage ../doc/manual/package.nix { version = fineVersion; };
   nix-internal-api-docs = callPackage ../src/internal-api-docs/package.nix { version = fineVersion; };

packaging/dependencies.nix

@@ -19,9 +19,7 @@ let
 
   root = ../.;
 
-  stdenv = if prevStdenv.isDarwin && prevStdenv.isx86_64
+  stdenv = if prevStdenv.isDarwin && prevStdenv.isx86_64 then darwinStdenv else prevStdenv;
-    then darwinStdenv
-    else prevStdenv;
 
   # Fix the following error with the default x86_64-darwin SDK:
   #
@@ -38,11 +36,14 @@ let
   # Indirection for Nixpkgs to override when package.nix files are vendored
   filesetToSource = lib.fileset.toSource;
 
-  /** Given a set of layers, create a mkDerivation-like function */
+  /**
-  mkPackageBuilder = exts: userFn:
+    Given a set of layers, create a mkDerivation-like function
-    stdenv.mkDerivation (lib.extends (lib.composeManyExtensions exts) userFn);
+  */
+  mkPackageBuilder =
+    exts: userFn: stdenv.mkDerivation (lib.extends (lib.composeManyExtensions exts) userFn);
 
-  localSourceLayer = finalAttrs: prevAttrs:
+  localSourceLayer =
+    finalAttrs: prevAttrs:
     let
       workDirPath =
         # Ideally we'd pick finalAttrs.workDir, but for now `mkDerivation` has
@@ -51,8 +52,13 @@ let
         prevAttrs.workDir;
 
       workDirSubpath = lib.path.removePrefix root workDirPath;
-      sources = assert prevAttrs.fileset._type == "fileset"; prevAttrs.fileset;
+      sources =
-      src = lib.fileset.toSource { fileset = sources; inherit root; };
+        assert prevAttrs.fileset._type == "fileset";
+        prevAttrs.fileset;
+      src = lib.fileset.toSource {
+        fileset = sources;
+        inherit root;
+      };
 
     in
     {
@@ -64,8 +70,7 @@ let
       workDir = null;
     };
 
-  mesonLayer = finalAttrs: prevAttrs:
+  mesonLayer = finalAttrs: prevAttrs: {
-    {
     # NOTE:
     # As of https://github.com/NixOS/nixpkgs/blob/8baf8241cea0c7b30e0b8ae73474cb3de83c1a30/pkgs/by-name/me/meson/setup-hook.sh#L26,
     # `mesonBuildType` defaults to `plain` if not specified. We want our Nix-built binaries to be optimized by default.
@@ -75,13 +80,18 @@ let
     # Users who are debugging Nix builds are expected to set the environment variable `mesonBuildType`, per the
     # guidance in https://github.com/NixOS/nix/blob/8a3fc27f1b63a08ac983ee46435a56cf49ebaf4a/doc/manual/source/development/debugging.md?plain=1#L10.
     # For this reason, we don't want to refer to `finalAttrs.mesonBuildType` here, but rather use the environment variable.
-      preConfigure = prevAttrs.preConfigure or "" + lib.optionalString (
+    preConfigure =
+      prevAttrs.preConfigure or ""
+      +
+        lib.optionalString
+          (
             !stdenv.hostPlatform.isWindows
             # build failure
             && !stdenv.hostPlatform.isStatic
             # LTO breaks exception handling on x86-64-darwin.
             && stdenv.system != "x86_64-darwin"
-      ) ''
+          )
+          ''
             case "$mesonBuildType" in
             release|minsize) appendToVar mesonFlags "-Db_lto=true"  ;;
             *)               appendToVar mesonFlags "-Db_lto=false" ;;
@@ -96,35 +106,34 @@ let
     ];
   };
 
-  mesonBuildLayer = finalAttrs: prevAttrs:
+  mesonBuildLayer = finalAttrs: prevAttrs: {
-    {
     nativeBuildInputs = prevAttrs.nativeBuildInputs or [ ] ++ [
       pkgs.buildPackages.pkg-config
     ];
     separateDebugInfo = !stdenv.hostPlatform.isStatic;
     hardeningDisable = lib.optional stdenv.hostPlatform.isStatic "pie";
-      env = prevAttrs.env or {}
+    env =
-        // lib.optionalAttrs
+      prevAttrs.env or { }
-          (stdenv.isLinux
+      // lib.optionalAttrs (
+        stdenv.isLinux
         && !(stdenv.hostPlatform.isStatic && stdenv.system == "aarch64-linux")
-            && !(stdenv.hostPlatform.useLLVM or false))
+        && !(stdenv.hostPlatform.useLLVM or false)
-          { LDFLAGS = "-fuse-ld=gold"; };
+      ) { LDFLAGS = "-fuse-ld=gold"; };
   };
 
-  mesonLibraryLayer = finalAttrs: prevAttrs:
+  mesonLibraryLayer = finalAttrs: prevAttrs: {
-    {
     outputs = prevAttrs.outputs or [ "out" ] ++ [ "dev" ];
   };
 
   # Work around weird `--as-needed` linker behavior with BSD, see
   # https://github.com/mesonbuild/meson/issues/3593
-  bsdNoLinkAsNeeded = finalAttrs: prevAttrs:
+  bsdNoLinkAsNeeded =
+    finalAttrs: prevAttrs:
     lib.optionalAttrs stdenv.hostPlatform.isBSD {
       mesonFlags = [ (lib.mesonBool "b_asneeded" false) ] ++ prevAttrs.mesonFlags or [ ];
     };
 
-  miscGoodPractice = finalAttrs: prevAttrs:
+  miscGoodPractice = finalAttrs: prevAttrs: {
-    {
     strictDeps = prevAttrs.strictDeps or true;
     enableParallelBuilding = true;
   };
@@ -132,10 +141,15 @@ in
 scope: {
   inherit stdenv;
 
-  aws-sdk-cpp = (pkgs.aws-sdk-cpp.override {
+  aws-sdk-cpp =
-    apis = [ "s3" "transfer" ];
+    (pkgs.aws-sdk-cpp.override {
+      apis = [
+        "s3"
+        "transfer"
+      ];
       customMemoryManagement = false;
-  }).overrideAttrs {
+    }).overrideAttrs
+      {
         # only a stripped down version is built, which takes a lot less resources
         # to build, so we don't need a "big-parallel" machine.
         requiredSystemFeatures = [ ];
@@ -146,35 +160,39 @@ scope: {
   };
 
   # TODO Hack until https://github.com/NixOS/nixpkgs/issues/45462 is fixed.
-  boost = (pkgs.boost.override {
+  boost =
+    (pkgs.boost.override {
       extraB2Args = [
         "--with-container"
         "--with-context"
         "--with-coroutine"
       ];
-  }).overrideAttrs (old: {
+    }).overrideAttrs
+      (old: {
         # Need to remove `--with-*` to use `--with-libraries=...`
         buildPhase = lib.replaceStrings [ "--without-python" ] [ "" ] old.buildPhase;
         installPhase = lib.replaceStrings [ "--without-python" ] [ "" ] old.installPhase;
       });
 
   libgit2 = pkgs.libgit2.overrideAttrs (attrs: {
-    cmakeFlags = attrs.cmakeFlags or []
+    cmakeFlags = attrs.cmakeFlags or [ ] ++ [ "-DUSE_SSH=exec" ];
-      ++ [ "-DUSE_SSH=exec" ];
+    nativeBuildInputs =
-    nativeBuildInputs = attrs.nativeBuildInputs or []
+      attrs.nativeBuildInputs or [ ]
       # gitMinimal does not build on Windows. See packbuilder patch.
       ++ lib.optionals (!stdenv.hostPlatform.isWindows) [
         # Needed for `git apply`; see `prePatch`
         pkgs.buildPackages.gitMinimal
       ];
     # Only `git apply` can handle git binary patches
-    prePatch = attrs.prePatch or ""
+    prePatch =
+      attrs.prePatch or ""
       + lib.optionalString (!stdenv.hostPlatform.isWindows) ''
         patch() {
           git apply
         }
       '';
-    patches = attrs.patches or []
+    patches =
+      attrs.patches or [ ]
       ++ [
         ./patches/libgit2-mempack-thin-packfile.patch
       ]
@@ -188,22 +206,19 @@ scope: {
 
   inherit resolvePath filesetToSource;
 
-  mkMesonDerivation =
+  mkMesonDerivation = mkPackageBuilder [
-    mkPackageBuilder [
     miscGoodPractice
     localSourceLayer
     mesonLayer
   ];
-  mkMesonExecutable =
+  mkMesonExecutable = mkPackageBuilder [
-    mkPackageBuilder [
     miscGoodPractice
     bsdNoLinkAsNeeded
     localSourceLayer
     mesonLayer
     mesonBuildLayer
   ];
-  mkMesonLibrary =
+  mkMesonLibrary = mkPackageBuilder [
-    mkPackageBuilder [
     miscGoodPractice
     bsdNoLinkAsNeeded
     localSourceLayer

packaging/dev-shell.nix

@@ -1,14 +1,20 @@
-{ lib, inputs, devFlake }:
+{
+  lib,
+  inputs,
+  devFlake,
+}:
 
 { pkgs }:
 
-pkgs.nixComponents.nix-util.overrideAttrs (attrs:
+pkgs.nixComponents.nix-util.overrideAttrs (
+  attrs:
 
   let
     stdenv = pkgs.nixDependencies.stdenv;
     buildCanExecuteHost = stdenv.buildPlatform.canExecute stdenv.hostPlatform;
     modular = devFlake.getSystem stdenv.buildPlatform.system;
-  transformFlag = prefix: flag:
+    transformFlag =
+      prefix: flag:
       assert builtins.isString flag;
       let
         rest = builtins.substring 2 (builtins.stringLength flag) flag;
@@ -16,7 +22,8 @@ let
       "-D${prefix}:${rest}";
     havePerl = stdenv.buildPlatform == stdenv.hostPlatform && stdenv.hostPlatform.isUnix;
     ignoreCrossFile = flags: builtins.filter (flag: !(lib.strings.hasInfix "cross-file" flag)) flags;
-in {
+  in
+  {
     pname = "shell-for-" + attrs.pname;
 
     # Remove the version suffix to avoid unnecessary attempts to substitute in nix develop
@@ -71,20 +78,23 @@ in {
       BOOST_INCLUDEDIR = "${lib.getDev pkgs.nixDependencies.boost}/include";
       BOOST_LIBRARYDIR = "${lib.getLib pkgs.nixDependencies.boost}/lib";
       # For `make format`, to work without installing pre-commit
-    _NIX_PRE_COMMIT_HOOKS_CONFIG =
+      _NIX_PRE_COMMIT_HOOKS_CONFIG = "${(pkgs.formats.yaml { }).generate "pre-commit-config.yaml"
-      "${(pkgs.formats.yaml { }).generate "pre-commit-config.yaml" modular.pre-commit.settings.rawConfig}";
+        modular.pre-commit.settings.rawConfig
+      }";
     };
 
     mesonFlags =
       map (transformFlag "libutil") (ignoreCrossFile pkgs.nixComponents.nix-util.mesonFlags)
       ++ map (transformFlag "libstore") (ignoreCrossFile pkgs.nixComponents.nix-store.mesonFlags)
       ++ map (transformFlag "libfetchers") (ignoreCrossFile pkgs.nixComponents.nix-fetchers.mesonFlags)
-    ++ lib.optionals havePerl (map (transformFlag "perl") (ignoreCrossFile pkgs.nixComponents.nix-perl-bindings.mesonFlags))
+      ++ lib.optionals havePerl (
+        map (transformFlag "perl") (ignoreCrossFile pkgs.nixComponents.nix-perl-bindings.mesonFlags)
+      )
       ++ map (transformFlag "libexpr") (ignoreCrossFile pkgs.nixComponents.nix-expr.mesonFlags)
-    ++ map (transformFlag "libcmd") (ignoreCrossFile pkgs.nixComponents.nix-cmd.mesonFlags)
+      ++ map (transformFlag "libcmd") (ignoreCrossFile pkgs.nixComponents.nix-cmd.mesonFlags);
-    ;
 
-  nativeBuildInputs = attrs.nativeBuildInputs or []
+    nativeBuildInputs =
+      attrs.nativeBuildInputs or [ ]
       ++ pkgs.nixComponents.nix-util.nativeBuildInputs
       ++ pkgs.nixComponents.nix-store.nativeBuildInputs
       ++ pkgs.nixComponents.nix-fetchers.nativeBuildInputs
@@ -94,28 +104,30 @@ in {
       ++ pkgs.nixComponents.nix-internal-api-docs.nativeBuildInputs
       ++ pkgs.nixComponents.nix-external-api-docs.nativeBuildInputs
       ++ pkgs.nixComponents.nix-functional-tests.externalNativeBuildInputs
-    ++ lib.optional
+      ++ lib.optional (
-      (!buildCanExecuteHost
+        !buildCanExecuteHost
         # Hack around https://github.com/nixos/nixpkgs/commit/bf7ad8cfbfa102a90463433e2c5027573b462479
         && !(stdenv.hostPlatform.isWindows && stdenv.buildPlatform.isDarwin)
         && stdenv.hostPlatform.emulatorAvailable pkgs.buildPackages
-         && lib.meta.availableOn stdenv.buildPlatform (stdenv.hostPlatform.emulator pkgs.buildPackages))
+        && lib.meta.availableOn stdenv.buildPlatform (stdenv.hostPlatform.emulator pkgs.buildPackages)
-      pkgs.buildPackages.mesonEmulatorHook
+      ) pkgs.buildPackages.mesonEmulatorHook
       ++ [
         pkgs.buildPackages.cmake
         pkgs.buildPackages.shellcheck
         pkgs.buildPackages.changelog-d
         modular.pre-commit.settings.package
-      (pkgs.writeScriptBin "pre-commit-hooks-install"
+        (pkgs.writeScriptBin "pre-commit-hooks-install" modular.pre-commit.settings.installationScript)
-        modular.pre-commit.settings.installationScript)
         inputs.nixfmt.packages.${pkgs.hostPlatform.system}.default
       ]
       # TODO: Remove the darwin check once
       # https://github.com/NixOS/nixpkgs/pull/291814 is available
       ++ lib.optional (stdenv.cc.isClang && !stdenv.buildPlatform.isDarwin) pkgs.buildPackages.bear
-    ++ lib.optional (stdenv.cc.isClang && stdenv.hostPlatform == stdenv.buildPlatform) (lib.hiPrio pkgs.buildPackages.clang-tools);
+      ++ lib.optional (stdenv.cc.isClang && stdenv.hostPlatform == stdenv.buildPlatform) (
+        lib.hiPrio pkgs.buildPackages.clang-tools
+      );
 
-  buildInputs = attrs.buildInputs or []
+    buildInputs =
+      attrs.buildInputs or [ ]
       ++ pkgs.nixComponents.nix-util.buildInputs
       ++ pkgs.nixComponents.nix-store.buildInputs
       ++ pkgs.nixComponents.nix-store-tests.externalBuildInputs
@@ -124,6 +136,6 @@ in {
       ++ pkgs.nixComponents.nix-expr.externalPropagatedBuildInputs
       ++ pkgs.nixComponents.nix-cmd.buildInputs
       ++ lib.optionals havePerl pkgs.nixComponents.nix-perl-bindings.externalBuildInputs
-    ++ lib.optional havePerl pkgs.perl
+      ++ lib.optional havePerl pkgs.perl;
-    ;
+  }
-})
+)

packaging/everything.nix

@@ -42,7 +42,8 @@
 }:
 
 let
-  libs = {
+  libs =
+    {
       inherit
         nix-util
         nix-util-c
@@ -57,7 +58,10 @@ let
         nix-main-c
         nix-cmd
         ;
-  } // lib.optionalAttrs (!stdenv.hostPlatform.isStatic && stdenv.buildPlatform.canExecute stdenv.hostPlatform) {
+    }
+    // lib.optionalAttrs
+      (!stdenv.hostPlatform.isStatic && stdenv.buildPlatform.canExecute stdenv.hostPlatform)
+      {
         # Currently fails in static build
         inherit
           nix-perl-bindings
@@ -77,8 +81,7 @@ let
     '';
     passthru = {
       tests = {
-        pkg-config =
+        pkg-config = testers.hasPkgConfigModules {
-          testers.hasPkgConfigModules {
           package = finalAttrs.finalPackage;
         };
       };
@@ -123,11 +126,14 @@ in
   ];
 
   meta.mainProgram = "nix";
-}).overrideAttrs (finalAttrs: prevAttrs: {
+}).overrideAttrs
+  (
+    finalAttrs: prevAttrs: {
       doCheck = true;
       doInstallCheck = true;
 
-  checkInputs = [
+      checkInputs =
+        [
           # Make sure the unit tests have passed
           nix-util-tests.tests.run
           nix-store-tests.tests.run
@@ -141,7 +147,10 @@ in
           # dev bundle is ok
           # (checkInputs must be empty paths??)
           (runCommand "check-pkg-config" { checked = dev.tests.pkg-config; } "mkdir $out")
-  ] ++ lib.optionals (!stdenv.hostPlatform.isStatic && stdenv.buildPlatform.canExecute stdenv.hostPlatform) [
+        ]
+        ++ lib.optionals
+          (!stdenv.hostPlatform.isStatic && stdenv.buildPlatform.canExecute stdenv.hostPlatform)
+          [
             # Perl currently fails in static build
             # TODO: Split out tests into a separate derivation?
             nix-perl-bindings
@@ -182,11 +191,19 @@ in
         inherit dev;
         inherit devdoc;
         doc = nix-manual;
-    outputs = [ "out" "dev" "devdoc" "doc" ];
+        outputs = [
-    all = lib.attrValues (lib.genAttrs finalAttrs.passthru.outputs (outName: finalAttrs.finalPackage.${outName}));
+          "out"
+          "dev"
+          "devdoc"
+          "doc"
+        ];
+        all = lib.attrValues (
+          lib.genAttrs finalAttrs.passthru.outputs (outName: finalAttrs.finalPackage.${outName})
+        );
       };
       meta = prevAttrs.meta // {
         description = "The Nix package manager";
         pkgConfigModules = dev.meta.pkgConfigModules;
       };
-})
+    }
+  )

packaging/hydra.nix

@@ -1,21 +1,24 @@
-{ inputs
+{
-, forAllCrossSystems
+  inputs,
-, forAllSystems
+  forAllCrossSystems,
-, lib
+  forAllSystems,
-, linux64BitSystems
+  lib,
-, nixpkgsFor
+  linux64BitSystems,
-, self
+  nixpkgsFor,
-, officialRelease
+  self,
+  officialRelease,
 }:
 let
   inherit (inputs) nixpkgs nixpkgs-regression;
 
-  installScriptFor = tarballs:
+  installScriptFor =
+    tarballs:
     nixpkgsFor.x86_64-linux.native.callPackage ./installer {
       inherit tarballs;
     };
 
-  testNixVersions = pkgs: daemon:
+  testNixVersions =
+    pkgs: daemon:
     pkgs.nixComponents.nix-functional-tests.override {
       pname = "nix-daemon-compat-tests";
       version = "${pkgs.nix.version}-with-daemon-${daemon.version}";
@@ -53,44 +56,72 @@ let
 in
 {
   # Binary package for various platforms.
-  build = forAllPackages (pkgName:
+  build = forAllPackages (
-    forAllSystems (system: nixpkgsFor.${system}.native.nixComponents.${pkgName}));
+    pkgName: forAllSystems (system: nixpkgsFor.${system}.native.nixComponents.${pkgName})
-
-  shellInputs = removeAttrs
-    (forAllSystems (system: self.devShells.${system}.default.inputDerivation))
-    [ "i686-linux" ];
-
-  buildStatic = forAllPackages (pkgName:
-    lib.genAttrs linux64BitSystems (system: nixpkgsFor.${system}.native.pkgsStatic.nixComponents.${pkgName}));
-
-  buildCross = forAllPackages (pkgName:
-    # Hack to avoid non-evaling package
-    (if pkgName == "nix-functional-tests" then lib.flip builtins.removeAttrs ["x86_64-w64-mingw32"] else lib.id)
-    (forAllCrossSystems (crossSystem:
-      lib.genAttrs [ "x86_64-linux" ] (system: nixpkgsFor.${system}.cross.${crossSystem}.nixComponents.${pkgName}))));
-
-  buildNoGc = let
-    components = forAllSystems (system:
-      nixpkgsFor.${system}.native.nixComponents.overrideScope (self: super: {
-        nix-expr = super.nix-expr.override { enableGC = false; };
-      })
   );
-  in forAllPackages (pkgName: forAllSystems (system: components.${system}.${pkgName}));
+
+  shellInputs = removeAttrs (forAllSystems (
+    system: self.devShells.${system}.default.inputDerivation
+  )) [ "i686-linux" ];
+
+  buildStatic = forAllPackages (
+    pkgName:
+    lib.genAttrs linux64BitSystems (
+      system: nixpkgsFor.${system}.native.pkgsStatic.nixComponents.${pkgName}
+    )
+  );
+
+  buildCross = forAllPackages (
+    pkgName:
+    # Hack to avoid non-evaling package
+    (
+      if pkgName == "nix-functional-tests" then
+        lib.flip builtins.removeAttrs [ "x86_64-w64-mingw32" ]
+      else
+        lib.id
+    )
+      (
+        forAllCrossSystems (
+          crossSystem:
+          lib.genAttrs [ "x86_64-linux" ] (
+            system: nixpkgsFor.${system}.cross.${crossSystem}.nixComponents.${pkgName}
+          )
+        )
+      )
+  );
+
+  buildNoGc =
+    let
+      components = forAllSystems (
+        system:
+        nixpkgsFor.${system}.native.nixComponents.overrideScope (
+          self: super: {
+            nix-expr = super.nix-expr.override { enableGC = false; };
+          }
+        )
+      );
+    in
+    forAllPackages (pkgName: forAllSystems (system: components.${system}.${pkgName}));
 
   buildNoTests = forAllSystems (system: nixpkgsFor.${system}.native.nixComponents.nix-cli);
 
   # Toggles some settings for better coverage. Windows needs these
   # library combinations, and Debian build Nix with GNU readline too.
-  buildReadlineNoMarkdown = let
+  buildReadlineNoMarkdown =
-    components = forAllSystems (system:
+    let
-      nixpkgsFor.${system}.native.nixComponents.overrideScope (self: super: {
+      components = forAllSystems (
+        system:
+        nixpkgsFor.${system}.native.nixComponents.overrideScope (
+          self: super: {
             nix-cmd = super.nix-cmd.override {
               enableMarkdown = false;
               readlineFlavor = "readline";
             };
-      })
+          }
+        )
       );
-  in forAllPackages (pkgName: forAllSystems (system: components.${system}.${pkgName}));
+    in
+    forAllPackages (pkgName: forAllSystems (system: components.${system}.${pkgName}));
 
   # Perl bindings for various platforms.
   perlBindings = forAllSystems (system: nixpkgsFor.${system}.native.nixComponents.nix-perl-bindings);
@@ -98,12 +129,16 @@ in
   # Binary tarball for various platforms, containing a Nix store
   # with the closure of 'nix' package, and the second half of
   # the installation script.
-  binaryTarball = forAllSystems (system:
+  binaryTarball = forAllSystems (
-    nixpkgsFor.${system}.native.callPackage ./binary-tarball.nix {});
+    system: nixpkgsFor.${system}.native.callPackage ./binary-tarball.nix { }
+  );
 
-  binaryTarballCross = lib.genAttrs [ "x86_64-linux" ] (system:
+  binaryTarballCross = lib.genAttrs [ "x86_64-linux" ] (
-    forAllCrossSystems (crossSystem:
+    system:
-      nixpkgsFor.${system}.cross.${crossSystem}.callPackage ./binary-tarball.nix {}));
+    forAllCrossSystems (
+      crossSystem: nixpkgsFor.${system}.cross.${crossSystem}.callPackage ./binary-tarball.nix { }
+    )
+  );
 
   # The first half of the installation script. This is uploaded
   # to https://nixos.org/nix/install. It downloads the binary
@@ -122,9 +157,12 @@ in
     self.hydraJobs.binaryTarballCross."x86_64-linux"."riscv64-unknown-linux-gnu"
   ];
 
-  installerScriptForGHA = forAllSystems (system: nixpkgsFor.${system}.native.callPackage ./installer {
+  installerScriptForGHA = forAllSystems (
+    system:
+    nixpkgsFor.${system}.native.callPackage ./installer {
       tarballs = [ self.hydraJobs.binaryTarball.${system} ];
-  });
+    }
+  );
 
   # docker image with Nix inside
   dockerImage = lib.genAttrs linux64BitSystems (system: self.packages.${system}.dockerImage);
@@ -145,10 +183,12 @@ in
   external-api-docs = nixpkgsFor.x86_64-linux.native.nixComponents.nix-external-api-docs;
 
   # System tests.
-  tests = import ../tests/nixos {
+  tests =
+    import ../tests/nixos {
       inherit lib nixpkgs nixpkgsFor;
       inherit (self.inputs) nixpkgs-23-11;
-  } // {
+    }
+    // {
 
       # Make sure that nix-env still produces the exact same result
       # on a particular version of Nixpkgs.
@@ -156,8 +196,7 @@ in
         let
           inherit (nixpkgsFor.x86_64-linux.native) runCommand nix;
         in
-      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.
           (
@@ -168,10 +207,9 @@ in
           mkdir $out
         '';
 
-    nixpkgsLibTests =
+      nixpkgsLibTests = forAllSystems (
-      forAllSystems (system:
+        system:
-        import (nixpkgs + "/lib/tests/test-with-nix.nix")
+        import (nixpkgs + "/lib/tests/test-with-nix.nix") {
-          {
           lib = nixpkgsFor.${system}.native.lib;
           nix = self.packages.${system}.nix-cli;
           pkgs = nixpkgsFor.${system}.native;
@@ -184,20 +222,21 @@ in
     nixpkgs = nixpkgs-regression;
   };
 
-  installTests = forAllSystems (system:
+  installTests = forAllSystems (
-    let pkgs = nixpkgsFor.${system}.native; in
+    system:
-    pkgs.runCommand "install-tests"
+    let
-      {
+      pkgs = nixpkgsFor.${system}.native;
+    in
+    pkgs.runCommand "install-tests" {
       againstSelf = testNixVersions pkgs pkgs.nix;
       againstCurrentLatest =
         # FIXME: temporarily disable this on macOS because of #3605.
-          if system == "x86_64-linux"
+        if system == "x86_64-linux" then testNixVersions pkgs pkgs.nixVersions.latest else null;
-          then testNixVersions pkgs pkgs.nixVersions.latest
-          else null;
       # Disabled because the latest stable version doesn't handle
       # `NIX_DAEMON_SOCKET_PATH` which is required for the tests to work
       # againstLatestStable = testNixVersions pkgs pkgs.nixStable;
-      } "touch $out");
+    } "touch $out"
+  );
 
   installerTests = import ../tests/installer {
     binaryTarballs = self.hydraJobs.binaryTarball;

packaging/installer/default.nix

@@ -1,12 +1,15 @@
-{ lib
+{
-, runCommand
+  lib,
-, nix
+  runCommand,
-, tarballs
+  nix,
+  tarballs,
 }:
 
-runCommand "installer-script" {
+runCommand "installer-script"
+  {
     buildInputs = [ nix ];
-} ''
+  }
+  ''
     mkdir -p $out/nix-support
 
     # Converts /nix/store/50p3qk8k...-nix-2.4pre20201102_550e11f/bin/nix to 50p3qk8k.../bin/nix.
@@ -21,15 +24,18 @@ runCommand "installer-script" {
     }
 
     substitute ${./install.in} $out/install \
-    ${lib.concatMapStrings
+      ${
-      (tarball: let
+        lib.concatMapStrings (
+          tarball:
+          let
             inherit (tarball.stdenv.hostPlatform) system;
-        in '' \
+          in
+          ''
+            \
                    --replace '@tarballHash_${system}@' $(nix --experimental-features nix-command hash-file --base16 --type sha256 ${tarball}/*.tar.xz) \
                    --replace '@tarballPath_${system}@' $(tarballPath ${tarball}/*.tar.xz) \
           ''
-      )
+        ) tarballs
-      tarballs
       } --replace '@nixVersion@' ${nix.version}
 
     echo "file installer $out/install" >> $out/nix-support/hydra-build-products

src/external-api-docs/package.nix

@@ -1,11 +1,12 @@
-{ lib
+{
-, mkMesonDerivation
+  lib,
+  mkMesonDerivation,
 
-, doxygen
+  doxygen,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -39,8 +40,7 @@ mkMesonDerivation (finalAttrs: {
     doxygen
   ];
 
-  preConfigure =
+  preConfigure = ''
-    ''
     chmod u+w ./.version
     echo ${finalAttrs.version} > ./.version
   '';

src/internal-api-docs/package.nix

@@ -1,11 +1,12 @@
-{ lib
+{
-, mkMesonDerivation
+  lib,
+  mkMesonDerivation,
 
-, doxygen
+  doxygen,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -17,9 +18,11 @@ mkMesonDerivation (finalAttrs: {
   inherit version;
 
   workDir = ./.;
-  fileset = let
+  fileset =
+    let
       cpp = fileset.fileFilter (file: file.hasExt "cc" || file.hasExt "hh");
-  in fileset.unions [
+    in
+    fileset.unions [
       ./.version
       ../../.version
       ./meson.build
@@ -33,8 +36,7 @@ mkMesonDerivation (finalAttrs: {
     doxygen
   ];
 
-  preConfigure =
+  preConfigure = ''
-    ''
     chmod u+w ./.version
     echo ${finalAttrs.version} > ./.version
   '';

src/libcmd/package.nix

@@ -1,24 +1,25 @@
-{ lib
+{
-, stdenv
+  lib,
-, mkMesonLibrary
+  stdenv,
+  mkMesonLibrary,
 
-, nix-util
+  nix-util,
-, nix-store
+  nix-store,
-, nix-fetchers
+  nix-fetchers,
-, nix-expr
+  nix-expr,
-, nix-flake
+  nix-flake,
-, nix-main
+  nix-main,
-, editline
+  editline,
-, readline
+  readline,
-, lowdown
+  lowdown,
-, nlohmann_json
+  nlohmann_json,
 
   # Configuration Options
 
-, version
+  version,
 
   # Whether to enable Markdown rendering in the Nix binary.
-, enableMarkdown ? !stdenv.hostPlatform.isWindows
+  enableMarkdown ? !stdenv.hostPlatform.isWindows,
 
   # Which interactive line editor library to use for Nix's repl.
   #
@@ -26,7 +27,7 @@
   #
   # - editline (default)
   # - readline
-, readlineFlavor ? if stdenv.hostPlatform.isWindows then "readline" else "editline"
+  readlineFlavor ? if stdenv.hostPlatform.isWindows then "readline" else "editline",
 }:
 
 let

src/libexpr-c/package.nix

@@ -1,12 +1,13 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-store-c
+  nix-store-c,
-, nix-expr
+  nix-expr,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libexpr-test-support/package.nix

@@ -1,15 +1,16 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-store-test-support
+  nix-store-test-support,
-, nix-expr
+  nix-expr,
-, nix-expr-c
+  nix-expr-c,
 
-, rapidcheck
+  rapidcheck,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libexpr-tests/package.nix

@@ -1,20 +1,21 @@
-{ lib
+{
-, buildPackages
+  lib,
-, stdenv
+  buildPackages,
-, mkMesonExecutable
+  stdenv,
+  mkMesonExecutable,
 
-, nix-expr
+  nix-expr,
-, nix-expr-c
+  nix-expr-c,
-, nix-expr-test-support
+  nix-expr-test-support,
 
-, rapidcheck
+  rapidcheck,
-, gtest
+  gtest,
-, runCommand
+  runCommand,
 
   # Configuration Options
 
-, version
+  version,
-, resolvePath
+  resolvePath,
 }:
 
 let
@@ -58,16 +59,22 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = runCommand "${finalAttrs.pname}-run" {
+      run =
+        runCommand "${finalAttrs.pname}-run"
+          {
             meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+          }
+          (
+            lib.optionalString stdenv.hostPlatform.isWindows ''
               export HOME="$PWD/home-dir"
               mkdir -p "$HOME"
-      '' + ''
+            ''
+            + ''
               export _NIX_TEST_UNIT_DATA=${resolvePath ./data}
               ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
               touch $out
-      '');
+            ''
+          );
     };
   };
 

src/libexpr/call-flake.nix

@@ -20,36 +20,33 @@ let
   # 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 attrpath (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.
         (resolveInput lockFile.nodes.${nodeName}.inputs.${builtins.head path})
         (builtins.tail path);
 
-  allNodes =
+  allNodes = builtins.mapAttrs (
-    builtins.mapAttrs
+    key: node:
-      (key: node:
     let
 
       parentNode = allNodes.${getInputByPath lockFile.root node.parent};
 
       sourceInfo =
-            if overrides ? ${key}
+        if overrides ? ${key} then
-            then
           overrides.${key}.sourceInfo
-            else if node.locked.type == "path" && builtins.substring 0 1 node.locked.path != "/"
+        else if node.locked.type == "path" && builtins.substring 0 1 node.locked.path != "/" then
-            then
+          parentNode.sourceInfo
-              parentNode.sourceInfo // {
+          // {
             outPath = parentNode.outPath + ("/" + node.locked.path);
           }
         else
@@ -63,9 +60,9 @@ 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 {});
+      );
 
       outputs = flake.outputs (inputs // { self = result; });
 
@@ -81,7 +78,10 @@ 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
@@ -90,7 +90,7 @@ let
       result
     else
       sourceInfo
-      )
+  ) lockFile.nodes;
-      lockFile.nodes;
 
-in allNodes.${lockFile.root}
+in
+allNodes.${lockFile.root}

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
-, 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";
 
@@ -30,11 +58,15 @@ derivation ({
 
     # This attribute does nothing; it's here to avoid changing evaluation results.
     impureEnvVars = [
-    "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/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;
@@ -18,4 +23,5 @@ let
 
   outputsList = map outputToAttrListElement outputs;
 
-in (builtins.head outputsList).value
+in
+(builtins.head outputsList).value

src/libexpr/package.nix

@@ -1,22 +1,23 @@
-{ lib
+{
-, stdenv
+  lib,
-, mkMesonLibrary
+  stdenv,
+  mkMesonLibrary,
 
-, bison
+  bison,
-, flex
+  flex,
-, cmake # for resolving toml11 dep
+  cmake, # for resolving toml11 dep
 
-, nix-util
+  nix-util,
-, nix-store
+  nix-store,
-, nix-fetchers
+  nix-fetchers,
-, boost
+  boost,
-, boehmgc
+  boehmgc,
-, nlohmann_json
+  nlohmann_json,
-, toml11
+  toml11,
 
   # Configuration Options
 
-, version
+  version,
 
   # Whether to use garbage collection for the Nix language evaluator.
   #
@@ -27,7 +28,7 @@
   #
   # Temporarily disabled on Windows because the `GC_throw_bad_alloc`
   # symbol is missing during linking.
-, enableGC ? !stdenv.hostPlatform.isWindows
+  enableGC ? !stdenv.hostPlatform.isWindows,
 }:
 
 let
@@ -51,10 +52,7 @@ mkMesonLibrary (finalAttrs: {
     (fileset.fileFilter (file: file.hasExt "hh") ./.)
     ./lexer.l
     ./parser.y
-    (fileset.difference
+    (fileset.difference (fileset.fileFilter (file: file.hasExt "nix") ./.) ./package.nix)
-      (fileset.fileFilter (file: file.hasExt "nix") ./.)
-      ./package.nix
-    )
   ];
 
   nativeBuildInputs = [

src/libexpr/primops/derivation.nix

@@ -26,19 +26,25 @@
   Note that `derivation` is very bare-bones, and provides almost no commands during the build.
   Most likely, you'll want to use functions like `stdenv.mkDerivation` in Nixpkgs to set up a basic environment.
 */
-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;
@@ -49,4 +55,5 @@ let
 
   outputsList = map outputToAttrListElement outputs;
 
-in (builtins.head outputsList).value
+in
+(builtins.head outputsList).value

src/libfetchers-tests/package.nix

@@ -1,19 +1,20 @@
-{ lib
+{
-, buildPackages
+  lib,
-, stdenv
+  buildPackages,
-, mkMesonExecutable
+  stdenv,
+  mkMesonExecutable,
 
-, nix-fetchers
+  nix-fetchers,
-, nix-store-test-support
+  nix-store-test-support,
 
-, rapidcheck
+  rapidcheck,
-, gtest
+  gtest,
-, runCommand
+  runCommand,
 
   # Configuration Options
 
-, version
+  version,
-, resolvePath
+  resolvePath,
 }:
 
 let
@@ -56,16 +57,22 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = runCommand "${finalAttrs.pname}-run" {
+      run =
+        runCommand "${finalAttrs.pname}-run"
+          {
             meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+          }
+          (
+            lib.optionalString stdenv.hostPlatform.isWindows ''
               export HOME="$PWD/home-dir"
               mkdir -p "$HOME"
-      '' + ''
+            ''
+            + ''
               export _NIX_TEST_UNIT_DATA=${resolvePath ./data}
               ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
               touch $out
-      '');
+            ''
+          );
     };
   };
 

src/libfetchers/package.nix

@@ -1,14 +1,15 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-util
+  nix-util,
-, nix-store
+  nix-store,
-, nlohmann_json
+  nlohmann_json,
-, libgit2
+  libgit2,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libflake-c/package.nix

@@ -1,13 +1,14 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-store-c
+  nix-store-c,
-, nix-expr-c
+  nix-expr-c,
-, nix-flake
+  nix-flake,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libflake-tests/package.nix

@@ -1,20 +1,21 @@
-{ lib
+{
-, buildPackages
+  lib,
-, stdenv
+  buildPackages,
-, mkMesonExecutable
+  stdenv,
+  mkMesonExecutable,
 
-, nix-flake
+  nix-flake,
-, nix-flake-c
+  nix-flake-c,
-, nix-expr-test-support
+  nix-expr-test-support,
 
-, rapidcheck
+  rapidcheck,
-, gtest
+  gtest,
-, runCommand
+  runCommand,
 
   # Configuration Options
 
-, version
+  version,
-, resolvePath
+  resolvePath,
 }:
 
 let
@@ -58,17 +59,23 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = runCommand "${finalAttrs.pname}-run" {
+      run =
+        runCommand "${finalAttrs.pname}-run"
+          {
             meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+          }
+          (
+            lib.optionalString stdenv.hostPlatform.isWindows ''
               export HOME="$PWD/home-dir"
               mkdir -p "$HOME"
-      '' + ''
+            ''
+            + ''
               export _NIX_TEST_UNIT_DATA=${resolvePath ./data}
               export NIX_CONFIG="extra-experimental-features = flakes"
               ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
               touch $out
-      '');
+            ''
+          );
     };
   };
 

src/libflake/package.nix

@@ -1,15 +1,16 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-util
+  nix-util,
-, nix-store
+  nix-store,
-, nix-fetchers
+  nix-fetchers,
-, nix-expr
+  nix-expr,
-, nlohmann_json
+  nlohmann_json,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libmain-c/package.nix

@@ -1,14 +1,15 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-util-c
+  nix-util-c,
-, nix-store
+  nix-store,
-, nix-store-c
+  nix-store-c,
-, nix-main
+  nix-main,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libmain/package.nix

@@ -1,14 +1,15 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, openssl
+  openssl,
 
-, nix-util
+  nix-util,
-, nix-store
+  nix-store,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libstore-c/package.nix

@@ -1,12 +1,13 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-util-c
+  nix-util-c,
-, nix-store
+  nix-store,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libstore-test-support/package.nix

@@ -1,15 +1,16 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-util-test-support
+  nix-util-test-support,
-, nix-store
+  nix-store,
-, nix-store-c
+  nix-store-c,
 
-, rapidcheck
+  rapidcheck,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libstore-tests/package.nix

@@ -1,21 +1,22 @@
-{ lib
+{
-, buildPackages
+  lib,
-, stdenv
+  buildPackages,
-, mkMesonExecutable
+  stdenv,
+  mkMesonExecutable,
 
-, nix-store
+  nix-store,
-, nix-store-c
+  nix-store-c,
-, nix-store-test-support
+  nix-store-test-support,
-, sqlite
+  sqlite,
 
-, rapidcheck
+  rapidcheck,
-, gtest
+  gtest,
-, runCommand
+  runCommand,
 
   # Configuration Options
 
-, version
+  version,
-, filesetToSource
+  filesetToSource,
 }:
 
 let
@@ -64,7 +65,8 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = let
+      run =
+        let
           # Some data is shared with the functional tests: they create it,
           # we consume it.
           data = filesetToSource {
@@ -74,16 +76,22 @@ mkMesonExecutable (finalAttrs: {
               ../../tests/functional/derivation
             ];
           };
-      in runCommand "${finalAttrs.pname}-run" {
+        in
+        runCommand "${finalAttrs.pname}-run"
+          {
             meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+          }
+          (
+            lib.optionalString stdenv.hostPlatform.isWindows ''
               export HOME="$PWD/home-dir"
               mkdir -p "$HOME"
-      '' + ''
+            ''
+            + ''
               export _NIX_TEST_UNIT_DATA=${data + "/src/libstore-tests/data"}
               ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
               touch $out
-      '');
+            ''
+          );
     };
   };
 

src/libstore/package.nix

@@ -1,25 +1,26 @@
-{ lib
+{
-, stdenv
+  lib,
-, mkMesonLibrary
+  stdenv,
+  mkMesonLibrary,
 
-, unixtools
+  unixtools,
-, darwin
+  darwin,
 
-, nix-util
+  nix-util,
-, boost
+  boost,
-, curl
+  curl,
-, aws-sdk-cpp
+  aws-sdk-cpp,
-, libseccomp
+  libseccomp,
-, nlohmann_json
+  nlohmann_json,
-, sqlite
+  sqlite,
 
-, busybox-sandbox-shell ? null
+  busybox-sandbox-shell ? null,
 
   # Configuration Options
 
-, version
+  version,
 
-, embeddedSandboxShell ? stdenv.hostPlatform.isStatic
+  embeddedSandboxShell ? stdenv.hostPlatform.isStatic,
 }:
 
 let
@@ -48,19 +49,20 @@ mkMesonLibrary (finalAttrs: {
     (fileset.fileFilter (file: file.hasExt "sql") ./.)
   ];
 
-  nativeBuildInputs =
+  nativeBuildInputs = lib.optional embeddedSandboxShell unixtools.hexdump;
-    lib.optional embeddedSandboxShell unixtools.hexdump;
 
-  buildInputs = [
+  buildInputs =
+    [
       boost
       curl
       sqlite
-  ] ++ lib.optional stdenv.hostPlatform.isLinux libseccomp
+    ]
+    ++ lib.optional stdenv.hostPlatform.isLinux libseccomp
     # There have been issues building these dependencies
     ++ lib.optional stdenv.hostPlatform.isDarwin darwin.apple_sdk.libs.sandbox
-    ++ lib.optional (stdenv.hostPlatform == stdenv.buildPlatform && (stdenv.isLinux || stdenv.isDarwin))
+    ++ lib.optional (
-      aws-sdk-cpp
+      stdenv.hostPlatform == stdenv.buildPlatform && (stdenv.isLinux || stdenv.isDarwin)
-  ;
+    ) aws-sdk-cpp;
 
   propagatedBuildInputs = [
     nix-util
@@ -75,10 +77,12 @@ mkMesonLibrary (finalAttrs: {
       echo ${version} > ../../.version
     '';
 
-  mesonFlags = [
+  mesonFlags =
+    [
       (lib.mesonEnable "seccomp-sandboxing" stdenv.hostPlatform.isLinux)
       (lib.mesonBool "embedded-sandbox-shell" embeddedSandboxShell)
-  ] ++ lib.optionals stdenv.hostPlatform.isLinux [
+    ]
+    ++ lib.optionals stdenv.hostPlatform.isLinux [
       (lib.mesonOption "sandbox-shell" "${busybox-sandbox-shell}/bin/busybox")
     ];
 

src/libutil-c/package.nix

@@ -1,11 +1,12 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-util
+  nix-util,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libutil-test-support/package.nix

@@ -1,14 +1,15 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-util
+  nix-util,
-, nix-util-c
+  nix-util-c,
 
-, rapidcheck
+  rapidcheck,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let

src/libutil-tests/package.nix

@@ -1,19 +1,20 @@
-{ lib
+{
-, buildPackages
+  lib,
-, stdenv
+  buildPackages,
-, mkMesonExecutable
+  stdenv,
+  mkMesonExecutable,
 
-, nix-util
+  nix-util,
-, nix-util-c
+  nix-util-c,
-, nix-util-test-support
+  nix-util-test-support,
 
-, rapidcheck
+  rapidcheck,
-, gtest
+  gtest,
-, runCommand
+  runCommand,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -57,16 +58,22 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = runCommand "${finalAttrs.pname}-run" {
+      run =
+        runCommand "${finalAttrs.pname}-run"
+          {
             meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+          }
+          (
+            lib.optionalString stdenv.hostPlatform.isWindows ''
               export HOME="$PWD/home-dir"
               mkdir -p "$HOME"
-      '' + ''
+            ''
+            + ''
               export _NIX_TEST_UNIT_DATA=${./data}
               ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
               touch $out
-      '');
+            ''
+          );
     };
   };
 

src/libutil/package.nix

@@ -1,18 +1,19 @@
-{ lib
+{
-, stdenv
+  lib,
-, mkMesonLibrary
+  stdenv,
+  mkMesonLibrary,
 
-, boost
+  boost,
-, brotli
+  brotli,
-, libarchive
+  libarchive,
-, libcpuid
+  libcpuid,
-, libsodium
+  libsodium,
-, nlohmann_json
+  nlohmann_json,
-, openssl
+  openssl,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -43,8 +44,7 @@ mkMesonLibrary (finalAttrs: {
     brotli
     libsodium
     openssl
-  ] ++ lib.optional stdenv.hostPlatform.isx86_64 libcpuid
+  ] ++ lib.optional stdenv.hostPlatform.isx86_64 libcpuid;
-  ;
 
   propagatedBuildInputs = [
     boost

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.

src/nix/package.nix

@@ -1,14 +1,15 @@
-{ lib
+{
-, mkMesonExecutable
+  lib,
+  mkMesonExecutable,
 
-, nix-store
+  nix-store,
-, nix-expr
+  nix-expr,
-, nix-main
+  nix-main,
-, nix-cmd
+  nix-cmd,
 
   # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -20,7 +21,8 @@ mkMesonExecutable (finalAttrs: {
   inherit version;
 
   workDir = ./.;
-  fileset = fileset.unions ([
+  fileset = fileset.unions (
+    [
       ../../nix-meson-build-support
       ./nix-meson-build-support
       ../../.version
@@ -61,7 +63,9 @@ mkMesonExecutable (finalAttrs: {
       ../../doc/manual/source/command-ref/files/profiles.md
 
       # Files
-  ] ++ lib.concatMap
+    ]
+    ++
+      lib.concatMap
         (dir: [
           (fileset.fileFilter (file: file.hasExt "cc") dir)
           (fileset.fileFilter (file: file.hasExt "hh") dir)

src/perl/package.nix

@@ -1,36 +1,41 @@
-{ lib
+{
-, stdenv
+  lib,
-, mkMesonDerivation
+  stdenv,
-, pkg-config
+  mkMesonDerivation,
-, perl
+  pkg-config,
-, perlPackages
+  perl,
-, nix-store
+  perlPackages,
-, version
+  nix-store,
-, curl
+  version,
-, bzip2
+  curl,
-, libsodium
+  bzip2,
+  libsodium,
 }:
 
 let
   inherit (lib) fileset;
 in
 
-perl.pkgs.toPerlModule (mkMesonDerivation (finalAttrs: {
+perl.pkgs.toPerlModule (
+  mkMesonDerivation (finalAttrs: {
     pname = "nix-perl";
     inherit version;
 
     workDir = ./.;
-  fileset = fileset.unions ([
+    fileset = fileset.unions (
+      [
         ./.version
         ../../.version
         ./MANIFEST
         ./lib
         ./meson.build
         ./meson.options
-  ] ++ lib.optionals finalAttrs.doCheck [
+      ]
+      ++ lib.optionals finalAttrs.doCheck [
         ./.yath.rc.in
         ./t
-  ]);
+      ]
+    );
 
     nativeBuildInputs = [
       pkg-config
@@ -73,4 +78,5 @@ perl.pkgs.toPerlModule (mkMesonDerivation (finalAttrs: {
     ];
 
     strictDeps = false;
-}))
+  })
+)

tests/functional/big-derivation-attr.nix

@@ -1,6 +1,25 @@
 let
   sixteenBytes = "0123456789abcdef";
-  times16 = s: builtins.concatStringsSep "" [s s s s s s s s s s s s s s s s];
+  times16 =
+    s:
+    builtins.concatStringsSep "" [
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+      s
+    ];
   exp = n: x: if n == 1 then x else times16 (exp (n - 1) x);
   sixteenMegabyte = exp 6 sixteenBytes;
 in

tests/functional/build-hook-ca-fixed.nix

@@ -4,18 +4,33 @@ with import ./config.nix;
 
 let
 
-  mkDerivation = args:
+  mkDerivation =
-    derivation ({
+    args:
+    derivation (
+      {
         inherit system;
         builder = busybox;
-      args = ["sh" "-e" args.builder or (builtins.toFile "builder-${args.name}.sh" ''
+        args = [
+          "sh"
+          "-e"
+          args.builder or (builtins.toFile "builder-${args.name}.sh" ''
             if [ -e "$NIX_ATTRS_SH_FILE" ]; then source $NIX_ATTRS_SH_FILE; fi;
             eval "$buildCommand"
-      '')];
+          '')
+        ];
         outputHashMode = "recursive";
         outputHashAlgo = "sha256";
-    } // removeAttrs args ["builder" "meta" "passthru"])
+      }
-    // { meta = args.meta or {}; passthru = args.passthru or {}; };
+      // removeAttrs args [
+        "builder"
+        "meta"
+        "passthru"
+      ]
+    )
+    // {
+      meta = args.meta or { };
+      passthru = args.passthru or { };
+    };
 
   input1 = mkDerivation {
     shell = busybox;
@@ -51,8 +66,7 @@ in
   shell = busybox;
   name = "build-remote";
   passthru = { inherit input1 input2 input3; };
-    buildCommand =
+  buildCommand = ''
-      ''
     read x < ${input1}
     read y < ${input3}
     echo "$x $y" > $out

tests/functional/build-hook.nix

@@ -1,26 +1,48 @@
-{ busybox, contentAddressed ? false }:
+{
+  busybox,
+  contentAddressed ? false,
+}:
 
 with import ./config.nix;
 
 let
 
-  caArgs = if contentAddressed then {
+  caArgs =
+    if contentAddressed then
+      {
         outputHashMode = "recursive";
         outputHashAlgo = "sha256";
         __contentAddressed = true;
-    } else {};
+      }
+    else
+      { };
 
-  mkDerivation = args:
+  mkDerivation =
-    derivation ({
+    args:
+    derivation (
+      {
         inherit system;
         builder = busybox;
-      args = ["sh" "-e" args.builder or (builtins.toFile "builder-${args.name}.sh" ''
+        args = [
+          "sh"
+          "-e"
+          args.builder or (builtins.toFile "builder-${args.name}.sh" ''
             if [ -e "$NIX_ATTRS_SH_FILE" ]; then source $NIX_ATTRS_SH_FILE; fi;
             eval "$buildCommand"
-      '')];
+          '')
-    } // removeAttrs args ["builder" "meta" "passthru"]
+        ];
-    // caArgs)
+      }
-    // { meta = args.meta or {}; passthru = args.passthru or {}; };
+      // removeAttrs args [
+        "builder"
+        "meta"
+        "passthru"
+      ]
+      // caArgs
+    )
+    // {
+      meta = args.meta or { };
+      passthru = args.passthru or { };
+    };
 
   input1 = mkDerivation {
     shell = busybox;
@@ -53,8 +75,7 @@ in
   shell = busybox;
   name = "build-remote";
   passthru = { inherit input1 input2 input3; };
-    buildCommand =
+  buildCommand = ''
-      ''
     read x < ${input1}
     read y < ${input3}
     echo "$x $y" > $out

tests/functional/ca-shell.nix

@@ -1 +1,5 @@
-{ inNixShell ? false, ... }@args: import ./shell.nix (args // { contentAddressed = true; })
+{
+  inNixShell ? false,
+  ...
+}@args:
+import ./shell.nix (args // { contentAddressed = true; })

tests/functional/ca/content-addressed.nix

@@ -1,13 +1,21 @@
 with import ./config.nix;
 
-let mkCADerivation = args: mkDerivation ({
+let
+  mkCADerivation =
+    args:
+    mkDerivation (
+      {
         __contentAddressed = true;
         outputHashMode = "recursive";
         outputHashAlgo = "sha256";
-} // args);
+      }
+      // args
+    );
 in
 
-{ seed ? 0 }:
+{
+  seed ? 0,
+}:
 # A simple content-addressed derivation.
 # The derivation can be arbitrarily modified by passing a different `seed`,
 # but the output will always be the same
@@ -23,7 +31,11 @@ rec {
   };
   rootCA = mkCADerivation {
     name = "rootCA";
-    outputs = [ "out" "dev" "foo" ];
+    outputs = [
+      "out"
+      "dev"
+      "foo"
+    ];
     buildCommand = ''
       echo "building a CA derivation"
       echo "The seed is ${toString seed}"

tests/functional/ca/nondeterministic.nix

@@ -1,10 +1,16 @@
 with import ./config.nix;
 
-let mkCADerivation = args: mkDerivation ({
+let
+  mkCADerivation =
+    args:
+    mkDerivation (
+      {
         __contentAddressed = true;
         outputHashMode = "recursive";
         outputHashAlgo = "sha256";
-} // args);
+      }
+      // args
+    );
 in
 
 rec {
@@ -15,7 +21,9 @@ rec {
       echo $(date) > $out/current-time
     '';
   };
-  dep = seed: mkCADerivation {
+  dep =
+    seed:
+    mkCADerivation {
       name = "dep";
       inherit seed;
       buildCommand = ''
@@ -32,4 +40,3 @@ rec {
     '';
   };
 }
-

tests/functional/ca/racy.nix

@@ -1,7 +1,6 @@
 # A derivation that would certainly fail if several builders tried to
 # build it at once.
 
-
 with import ./config.nix;
 
 mkDerivation {

tests/functional/check-refs.nix

@@ -4,9 +4,14 @@ rec {
 
   dep = import ./dependencies.nix { };
 
-  makeTest = nr: args: mkDerivation ({
+  makeTest =
+    nr: args:
+    mkDerivation (
+      {
         name = "check-refs-" + toString nr;
-  } // args);
+      }
+      // args
+    );
 
   src = builtins.toFile "aux-ref" "bla bla";
 

tests/functional/check-reqs.nix

@@ -22,7 +22,9 @@ rec {
     '';
   };
 
-  makeTest = nr: allowreqs: mkDerivation {
+  makeTest =
+    nr: allowreqs:
+    mkDerivation {
       name = "check-reqs-" + toString nr;
       inherit deps;
       builder = builtins.toFile "builder.sh" ''
@@ -33,11 +35,21 @@ rec {
     };
 
   # When specifying all the requisites, the build succeeds.
-  test1 = makeTest 1 [ dep1 dep2 deps ];
+  test1 = makeTest 1 [
+    dep1
+    dep2
+    deps
+  ];
 
   # But missing anything it fails.
-  test2 = makeTest 2 [ dep2 deps ];
+  test2 = makeTest 2 [
-  test3 = makeTest 3 [ dep1 deps ];
+    dep2
+    deps
+  ];
+  test3 = makeTest 3 [
+    dep1
+    deps
+  ];
   test4 = makeTest 4 [ deps ];
   test5 = makeTest 5 [ ];
 

tests/functional/check.nix

@@ -1,4 +1,6 @@
-{checkBuildId ? 0}:
+{
+  checkBuildId ? 0,
+}:
 
 with import ./config.nix;
 
@@ -6,8 +8,7 @@ with import ./config.nix;
   nondeterministic = mkDerivation {
     inherit checkBuildId;
     name = "nondeterministic";
-    buildCommand =
+    buildCommand = ''
-      ''
       mkdir $out
       date +%s.%N > $out/date
       echo "CHECK_TMPDIR=$TMPDIR"
@@ -19,8 +20,7 @@ with import ./config.nix;
   deterministic = mkDerivation {
     inherit checkBuildId;
     name = "deterministic";
-    buildCommand =
+    buildCommand = ''
-      ''
       mkdir $out
       echo date > $out/date
       echo "CHECK_TMPDIR=$TMPDIR"
@@ -32,8 +32,7 @@ with import ./config.nix;
   failed = mkDerivation {
     inherit checkBuildId;
     name = "failed";
-    buildCommand =
+    buildCommand = ''
-      ''
       mkdir $out
       echo date > $out/date
       echo "CHECK_TMPDIR=$TMPDIR"

tests/functional/dependencies.nix

@@ -1,4 +1,6 @@
-{ hashInvalidator ? "" }:
+{
+  hashInvalidator ? "",
+}:
 with import ./config.nix;
 
 let

tests/functional/derivation/advanced-attributes-defaults.nix

@@ -2,5 +2,8 @@ derivation {
   name = "advanced-attributes-defaults";
   system = "my-system";
   builder = "/bin/bash";
-  args = [ "-c" "echo hello > $out" ];
+  args = [
+    "-c"
+    "echo hello > $out"
+  ];
 }

tests/functional/derivation/advanced-attributes-structured-attrs-defaults.nix

@@ -2,7 +2,13 @@ derivation {
   name = "advanced-attributes-structured-attrs-defaults";
   system = "my-system";
   builder = "/bin/bash";
-  args = [ "-c" "echo hello > $out" ];
+  args = [
-  outputs = [ "out" "dev" ];
+    "-c"
+    "echo hello > $out"
+  ];
+  outputs = [
+    "out"
+    "dev"
+  ];
   __structuredAttrs = true;
 }

tests/functional/derivation/advanced-attributes-structured-attrs.nix

@@ -4,26 +4,39 @@ let
     inherit system;
     name = "foo";
     builder = "/bin/bash";
-    args = ["-c" "echo foo > $out"];
+    args = [
+      "-c"
+      "echo foo > $out"
+    ];
   };
   bar = derivation {
     inherit system;
     name = "bar";
     builder = "/bin/bash";
-    args = ["-c" "echo bar > $out"];
+    args = [
+      "-c"
+      "echo bar > $out"
+    ];
   };
 in
 derivation {
   inherit system;
   name = "advanced-attributes-structured-attrs";
   builder = "/bin/bash";
-  args = [ "-c" "echo hello > $out" ];
+  args = [
+    "-c"
+    "echo hello > $out"
+  ];
   __sandboxProfile = "sandcastle";
   __noChroot = true;
   __impureHostDeps = [ "/usr/bin/ditto" ];
   impureEnvVars = [ "UNICORN" ];
   __darwinAllowLocalNetworking = true;
-  outputs = [ "out" "bin" "dev" ];
+  outputs = [
+    "out"
+    "bin"
+    "dev"
+  ];
   __structuredAttrs = true;
   outputChecks = {
     out = {
@@ -39,7 +52,10 @@ derivation {
       maxClosureSize = 5909;
     };
   };
-  requiredSystemFeatures = ["rainbow" "uid-range"];
+  requiredSystemFeatures = [
+    "rainbow"
+    "uid-range"
+  ];
   preferLocalBuild = true;
   allowSubstitutes = false;
 }

tests/functional/derivation/advanced-attributes.nix

@@ -4,20 +4,29 @@ let
     inherit system;
     name = "foo";
     builder = "/bin/bash";
-    args = ["-c" "echo foo > $out"];
+    args = [
+      "-c"
+      "echo foo > $out"
+    ];
   };
   bar = derivation {
     inherit system;
     name = "bar";
     builder = "/bin/bash";
-    args = ["-c" "echo bar > $out"];
+    args = [
+      "-c"
+      "echo bar > $out"
+    ];
   };
 in
 derivation {
   inherit system;
   name = "advanced-attributes";
   builder = "/bin/bash";
-  args = [ "-c" "echo hello > $out" ];
+  args = [
+    "-c"
+    "echo hello > $out"
+  ];
   __sandboxProfile = "sandcastle";
   __noChroot = true;
   __impureHostDeps = [ "/usr/bin/ditto" ];
@@ -27,7 +36,10 @@ derivation {
   allowedRequisites = [ foo ];
   disallowedReferences = [ bar ];
   disallowedRequisites = [ bar ];
-  requiredSystemFeatures = ["rainbow" "uid-range"];
+  requiredSystemFeatures = [
+    "rainbow"
+    "uid-range"
+  ];
   preferLocalBuild = true;
   allowSubstitutes = false;
 }

tests/functional/dyn-drv/recursive-mod-json.nix

@@ -1,6 +1,8 @@
 with import ./config.nix;
 
-let innerName = "foo"; in
+let
+  innerName = "foo";
+in
 
 mkDerivation rec {
   name = "${innerName}.drv";

tests/functional/export-graph.nix

@@ -2,8 +2,7 @@ with import ./config.nix;
 
 rec {
 
-  printRefs =
+  printRefs = ''
-    ''
     echo $exportReferencesGraph
     while read path; do
         read drv
@@ -17,13 +16,19 @@ rec {
   foo."bar.runtimeGraph" = mkDerivation {
     name = "dependencies";
     builder = builtins.toFile "build-graph-builder" "${printRefs}";
-    exportReferencesGraph = ["refs" (import ./dependencies.nix {})];
+    exportReferencesGraph = [
+      "refs"
+      (import ./dependencies.nix { })
+    ];
   };
 
   foo."bar.buildGraph" = mkDerivation {
     name = "dependencies";
     builder = builtins.toFile "build-graph-builder" "${printRefs}";
-    exportReferencesGraph = ["refs" (import ./dependencies.nix {}).drvPath];
+    exportReferencesGraph = [
+      "refs"
+      (import ./dependencies.nix { }).drvPath
+    ];
   };
 
 }

tests/functional/failing.nix

@@ -2,16 +2,29 @@
 with import ./config.nix;
 let
 
-  mkDerivation = args:
+  mkDerivation =
-    derivation ({
+    args:
+    derivation (
+      {
         inherit system;
         builder = busybox;
-      args = ["sh" "-e" args.builder or (builtins.toFile "builder-${args.name}.sh" ''
+        args = [
+          "sh"
+          "-e"
+          args.builder or (builtins.toFile "builder-${args.name}.sh" ''
             if [ -e "$NIX_ATTRS_SH_FILE" ]; then source $NIX_ATTRS_SH_FILE; fi;
             eval "$buildCommand"
-      '')];
+          '')
-    } // removeAttrs args ["builder" "meta"])
+        ];
-    // { meta = args.meta or {}; };
+      }
+      // removeAttrs args [
+        "builder"
+        "meta"
+      ]
+    )
+    // {
+      meta = args.meta or { };
+    };
 in
 {
 

tests/functional/filter-source.nix

@@ -4,9 +4,12 @@ mkDerivation {
   name = "filter";
   builder = builtins.toFile "builder" "ln -s $input $out";
   input =
-    let filter = path: type:
+    let
+      filter =
+        path: type:
         type != "symlink"
         && baseNameOf path != "foo"
         && !((import ./lang/lib.nix).hasSuffix ".bak" (baseNameOf path));
-    in builtins.filterSource filter ((builtins.getEnv "TEST_ROOT") + "/filterin");
+    in
+    builtins.filterSource filter ((builtins.getEnv "TEST_ROOT") + "/filterin");
 }

tests/functional/fixed.nix

@@ -2,14 +2,19 @@ with import ./config.nix;
 
 rec {
 
-  f2 = dummy: builder: mode: algo: hash: mkDerivation {
+  f2 =
+    dummy: builder: mode: algo: hash:
+    mkDerivation {
       name = "fixed";
       inherit builder;
       outputHashMode = mode;
       outputHashAlgo = algo;
       outputHash = hash;
       inherit dummy;
-    impureEnvVars = ["IMPURE_VAR1" "IMPURE_VAR2"];
+      impureEnvVars = [
+        "IMPURE_VAR1"
+        "IMPURE_VAR2"
+      ];
     };
 
   f = f2 "";
@@ -37,7 +42,8 @@ rec {
   ];
 
   sameAsAdd =
-    f ./fixed.builder2.sh "recursive" "sha256" "1ixr6yd3297ciyp9im522dfxpqbkhcw0pylkb2aab915278fqaik";
+    f ./fixed.builder2.sh "recursive" "sha256"
+      "1ixr6yd3297ciyp9im522dfxpqbkhcw0pylkb2aab915278fqaik";
 
   bad = [
     (f ./fixed.builder1.sh "flat" "md5" "0ddd8be4b179a529afa5f2ffae4b9858")

tests/functional/fod-failing.nix

@@ -2,8 +2,7 @@ with import ./config.nix;
 rec {
   x1 = mkDerivation {
     name = "x1";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
       echo $name > $out
     '';
     outputHashMode = "recursive";
@@ -11,8 +10,7 @@ rec {
   };
   x2 = mkDerivation {
     name = "x2";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
       echo $name > $out
     '';
     outputHashMode = "recursive";
@@ -20,8 +18,7 @@ rec {
   };
   x3 = mkDerivation {
     name = "x3";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
       echo $name > $out
     '';
     outputHashMode = "recursive";
@@ -30,8 +27,7 @@ rec {
   x4 = mkDerivation {
     name = "x4";
     inherit x2 x3;
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
       echo $x2 $x3
       exit 1
     '';

tests/functional/gc-concurrent.nix

@@ -1,6 +1,8 @@
 with import ./config.nix;
 
-{ lockFifo ? null }:
+{
+  lockFifo ? null,
+}:
 
 rec {
 

tests/functional/hash-check.nix

@@ -4,14 +4,22 @@ let {
     name = "dependencies-input-1";
     system = "i086-msdos";
     builder = "/bar/sh";
-    args = ["-e" "-x" ./dummy];
+    args = [
+      "-e"
+      "-x"
+      ./dummy
+    ];
   };
 
   input2 = derivation {
     name = "dependencies-input-2";
     system = "i086-msdos";
     builder = "/bar/sh";
-    args = ["-e" "-x" ./dummy];
+    args = [
+      "-e"
+      "-x"
+      ./dummy
+    ];
     outputHashMode = "recursive";
     outputHashAlgo = "md5";
     outputHash = "ffffffffffffffffffffffffffffffff";
@@ -21,7 +29,11 @@ let {
     name = "dependencies";
     system = "i086-msdos";
     builder = "/bar/sh";
-    args = ["-e" "-x" (./dummy  + "/FOOBAR/../.")];
+    args = [
+      "-e"
+      "-x"
+      (./dummy + "/FOOBAR/../.")
+    ];
     input1 = input1 + "/.";
     inherit input2;
   };

tests/functional/hermetic.nix

@@ -1,31 +1,51 @@
-{ busybox
+{
-, seed
+  busybox,
+  seed,
   # If we want the final derivation output to have references to its
   # dependencies. Some tests need/want this, other don't.
-, withFinalRefs ? false
+  withFinalRefs ? false,
 }:
 
 with import ./config.nix;
 
 let
   contentAddressedByDefault = builtins.getEnv "NIX_TESTS_CA_BY_DEFAULT" == "1";
-  caArgs = if contentAddressedByDefault then {
+  caArgs =
+    if contentAddressedByDefault then
+      {
         __contentAddressed = true;
         outputHashMode = "recursive";
         outputHashAlgo = "sha256";
-  } else {};
+      }
+    else
+      { };
 
-  mkDerivation = args:
+  mkDerivation =
-    derivation ({
+    args:
+    derivation (
+      {
         inherit system;
         builder = busybox;
-      args = ["sh" "-e" args.builder or (builtins.toFile "builder-${args.name}.sh" ''
+        args = [
+          "sh"
+          "-e"
+          args.builder or (builtins.toFile "builder-${args.name}.sh" ''
             if [ -e "$NIX_ATTRS_SH_FILE" ]; then source $NIX_ATTRS_SH_FILE; fi;
             eval "$buildCommand"
-      '')];
+          '')
-    } // removeAttrs args ["builder" "meta" "passthru"]
+        ];
-    // caArgs)
+      }
-    // { meta = args.meta or {}; passthru = args.passthru or {}; };
+      // removeAttrs args [
+        "builder"
+        "meta"
+        "passthru"
+      ]
+      // caArgs
+    )
+    // {
+      meta = args.meta or { };
+      passthru = args.passthru or { };
+    };
 
   input1 = mkDerivation {
     shell = busybox;
@@ -55,10 +75,11 @@ in
   shell = busybox;
   name = "hermetic";
   passthru = { inherit input1 input2 input3; };
-    buildCommand =
+  buildCommand = ''
-      ''
     read x < ${input1}
     read y < ${input3}
-        echo ${if (builtins.trace withFinalRefs withFinalRefs) then "${input1} ${input3}" else ""} "$x $y" > $out
+    echo ${
+      if (builtins.trace withFinalRefs withFinalRefs) then "${input1} ${input3}" else ""
+    } "$x $y" > $out
   '';
 }

tests/functional/ifd.nix

@@ -1,10 +1,8 @@
 with import ./config.nix;
-import (
+import (mkDerivation {
-  mkDerivation {
   name = "foo";
   bla = import ./dependencies.nix { };
   buildCommand = "
       echo \\\"hi\\\" > $out
     ";
-  }
+})
-)

tests/functional/import-from-derivation.nix

@@ -3,8 +3,7 @@ with import <config>;
 rec {
   bar = mkDerivation {
     name = "bar";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
       echo 'builtins.add 123 456' > $out
     '';
   };
@@ -16,8 +15,7 @@ rec {
 
   result = mkDerivation {
     name = "foo";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
       echo -n FOO${toString value} > $out
     '';
   };
@@ -25,8 +23,7 @@ rec {
   addPath = mkDerivation {
     name = "add-path";
     src = builtins.filterSource (path: type: true) result;
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
       echo -n BLA$(cat $src) > $out
     '';
   };

tests/functional/impure-derivations.nix

@@ -4,9 +4,11 @@ rec {
 
   impure = mkDerivation {
     name = "impure";
-    outputs = [ "out" "stuff" ];
+    outputs = [
-    buildCommand =
+      "out"
-      ''
+      "stuff"
+    ];
+    buildCommand = ''
       echo impure
       x=$(< $TEST_ROOT/counter)
       mkdir $out $stuff
@@ -20,8 +22,7 @@ rec {
 
   impureOnImpure = mkDerivation {
     name = "impure-on-impure";
-    buildCommand =
+    buildCommand = ''
-      ''
       echo impure-on-impure
       x=$(< ${impure}/n)
       mkdir $out
@@ -35,16 +36,14 @@ rec {
   # This is not allowed.
   inputAddressed = mkDerivation {
     name = "input-addressed";
-    buildCommand =
+    buildCommand = ''
-      ''
       cat ${impure} > $out
     '';
   };
 
   contentAddressed = mkDerivation {
     name = "content-addressed";
-    buildCommand =
+    buildCommand = ''
-      ''
       echo content-addressed
       x=$(< ${impureOnImpure}/n)
       printf ''${x:0:1} > $out
@@ -55,8 +54,7 @@ rec {
 
   inputAddressedAfterCA = mkDerivation {
     name = "input-addressed-after-ca";
-    buildCommand =
+    buildCommand = ''
-      ''
       cat ${contentAddressed} > $out
     '';
   };

tests/functional/lang-gc/issue-11141-gc-coroutine-test.nix

@@ -1,4 +1,3 @@
-
 # Run:
 # GC_INITIAL_HEAP_SIZE=$[1024 * 1024] NIX_SHOW_STATS=1 nix eval -f gc-coroutine-test.nix  -vvvv
 
@@ -11,10 +10,12 @@ let
   # Generate a tree of numbers, n deep, such that the numbers add up to (1 + salt) * 10^n.
   # The salting makes the numbers all different, increasing the likelihood of catching
   # any memory corruptions that might be caused by the GC or otherwise.
-  garbage = salt: n:
+  garbage =
-    if n == 0
+    salt: n:
-    then [(1 + salt)]
+    if n == 0 then
-    else [
+      [ (1 + salt) ]
+    else
+      [
         (garbage (10 * salt + 1) (n - 1))
         (garbage (10 * salt - 1) (n - 1))
         (garbage (10 * salt + 2) (n - 1))
@@ -27,39 +28,38 @@ let
         (garbage (10 * salt - 5) (n - 1))
       ];
 
-  pow = base: n:
+  pow = base: n: if n == 0 then 1 else base * (pow base (n - 1));
-    if n == 0
-    then 1
-    else base * (pow base (n - 1));
 
-  sumNestedLists = l:
+  sumNestedLists = l: if isList l then foldl' (a: b: a + sumNestedLists b) 0 l else l;
-    if isList l
-    then foldl' (a: b: a + sumNestedLists b) 0 l
-    else l;
 
 in
 assert sumNestedLists (garbage 0 3) == pow 10 3;
 assert sumNestedLists (garbage 0 6) == pow 10 6;
 builtins.foldl'
-    (a: b:
+  (
+    a: b:
     assert
-        "${
+      "${builtins.path {
-          builtins.path {
         path = ./src;
-            filter = path: type:
+        filter =
+          path: type:
           # We're not doing common subexpression elimination, so this reallocates
           # the fairly big tree over and over, producing a lot of garbage during
           # source filtering, whose filter runs in a coroutine.
           assert sumNestedLists (garbage 0 3) == pow 10 3;
           true;
-          }
+      }}" == "${./src}";
-        }"
-          == "${./src}";
 
     # These asserts don't seem necessary, as the lambda value get corrupted first
     assert a.okay;
     assert b.okay;
-      { okay = true; }
+    {
+      okay = true;
+    }
   )
   { okay = true; }
-    [ { okay = true; } { okay = true; } { okay = true; } ]
+  [
+    { okay = true; }
+    { okay = true; }
+    { okay = true; }
+  ]

tests/functional/lang/eval-fail-addDrvOutputDependencies-multi-elem-context.nix

@@ -3,16 +3,23 @@ let
     name = "fail";
     builder = "/bin/false";
     system = "x86_64-linux";
-    outputs = [ "out" "foo" ];
+    outputs = [
+      "out"
+      "foo"
+    ];
   };
 
   drv1 = derivation {
     name = "fail-2";
     builder = "/bin/false";
     system = "x86_64-linux";
-    outputs = [ "out" "foo" ];
+    outputs = [
+      "out"
+      "foo"
+    ];
   };
 
   combo-path = "${drv0.drvPath}${drv1.drvPath}";
 
-in builtins.addDrvOutputDependencies combo-path
+in
+builtins.addDrvOutputDependencies combo-path

tests/functional/lang/eval-fail-addDrvOutputDependencies-wrong-element-kind.nix

@@ -3,7 +3,11 @@ let
     name = "fail";
     builder = "/bin/false";
     system = "x86_64-linux";
-    outputs = [ "out" "foo" ];
+    outputs = [
+      "out"
+      "foo"
+    ];
   };
 
-in builtins.addDrvOutputDependencies drv.outPath
+in
+builtins.addDrvOutputDependencies drv.outPath

tests/functional/lang/eval-fail-addErrorContext-example.nix

@@ -1,9 +1,9 @@
 let
-  countDown = n:
+  countDown =
-    if n == 0
+    n:
-    then throw "kaboom"
+    if n == 0 then
+      throw "kaboom"
     else
-      builtins.addErrorContext
+      builtins.addErrorContext "while counting down; n = ${toString n}" ("x" + countDown (n - 1));
-        "while counting down; n = ${toString n}"
+in
-        ("x" + countDown (n - 1));
+countDown 10
-in countDown 10

tests/functional/lang/eval-fail-assert-equal-attrs-names-2.nix

@@ -1,2 +1,8 @@
-assert { a = true; } == { a = true; b = true; };
+assert
+  {
+    a = true;
+  } == {
+    a = true;
+    b = true;
+  };
 throw "unreachable"

tests/functional/lang/eval-fail-assert-equal-attrs-names.nix

@@ -1,2 +1,8 @@
-assert { a = true; b = true; } == { a = true; };
+assert
+  {
+    a = true;
+    b = true;
+  } == {
+    a = true;
+  };
 throw "unreachable"

tests/functional/lang/eval-fail-assert-equal-derivations-extra.nix

@@ -1,5 +1,14 @@
 assert
-  { foo = { type = "derivation"; outPath = "/nix/store/0"; }; }
+  {
-  ==
+    foo = {
-  { foo = { type = "derivation"; outPath = "/nix/store/1"; devious = true; }; };
+      type = "derivation";
+      outPath = "/nix/store/0";
+    };
+  } == {
+    foo = {
+      type = "derivation";
+      outPath = "/nix/store/1";
+      devious = true;
+    };
+  };
 throw "unreachable"

tests/functional/lang/eval-fail-assert-equal-derivations.nix

@@ -1,5 +1,15 @@
 assert
-  { foo = { type = "derivation"; outPath = "/nix/store/0"; ignored = abort "not ignored"; }; }
+  {
-  ==
+    foo = {
-  { foo = { type = "derivation"; outPath = "/nix/store/1"; ignored = abort "not ignored"; }; };
+      type = "derivation";
+      outPath = "/nix/store/0";
+      ignored = abort "not ignored";
+    };
+  } == {
+    foo = {
+      type = "derivation";
+      outPath = "/nix/store/1";
+      ignored = abort "not ignored";
+    };
+  };
 throw "unreachable"

tests/functional/lang/eval-fail-assert-equal-function-direct.nix

@@ -1,7 +1,4 @@
 # Note: functions in nested structures, e.g. attributes, may be optimized away by pointer identity optimization.
 # This only compares a direct comparison and makes no claims about functions in nested structures.
-assert
+assert (x: x) == (x: x);
-  (x: x)
-  ==
-  (x: x);
 abort "unreachable"

tests/functional/lang/eval-fail-assert-equal-list-length.nix

@@ -1,2 +1,6 @@
-assert [ 1 0 ] == [ 10 ];
+assert
+  [
+    1
+    0
+  ] == [ 10 ];
 throw "unreachable"

tests/functional/lang/eval-fail-assert-nested-bool.nix

@@ -1,6 +1,3 @@
-assert
+assert { a.b = [ { c.d = true; } ]; } == { a.b = [ { c.d = false; } ]; };
-  { a.b = [ { c.d = true; } ]; }
-  ==
-  { a.b = [ { c.d = false; } ]; };
 
 abort "unreachable"

tests/functional/lang/eval-fail-assert.nix

@@ -1,5 +1,8 @@
 let {
-  x = arg: assert arg == "y"; 123;
+  x =
+    arg:
+    assert arg == "y";
+    123;
 
   body = x "x";
 }

tests/functional/lang/eval-fail-attrset-merge-drops-later-rec.nix

@@ -1 +1,8 @@
-{ a.b = 1; a = rec { c = d + 2; d = 3; }; }.c
+{
+  a.b = 1;
+  a = rec {
+    c = d + 2;
+    d = 3;
+  };
+}
+.c

tests/functional/lang/eval-fail-bad-string-interpolation-4.nix

@@ -1,6 +1,16 @@
 let
   # Basically a "billion laughs" attack, but toned down to simulated `pkgs`.
-  ha = x: y: { a = x y; b = x y; c = x y; d = x y; e = x y; f = x y; g = x y; h = x y; j = x y; };
+  ha = x: y: {
+    a = x y;
+    b = x y;
+    c = x y;
+    d = x y;
+    e = x y;
+    f = x y;
+    g = x y;
+    h = x y;
+    j = x y;
+  };
   has = ha (ha (ha (ha (x: x)))) "ha";
   # A large structure that has already been evaluated.
   pkgs = builtins.deepSeq has has;

tests/functional/lang/eval-fail-dup-dynamic-attrs.nix

@@ -1,4 +1,8 @@
 {
-  set = { "${"" + "b"}" = 1; };
+  set = {
-  set = { "${"b" + ""}" = 2; };
+    "${"" + "b"}" = 1;
+  };
+  set = {
+    "${"b" + ""}" = 2;
+  };
 }

tests/functional/lang/eval-fail-duplicate-traces.nix

@@ -1,9 +1,6 @@
 # Check that we only omit duplicate stack traces when there's a bunch of them.
 # Here, there's only a couple duplicate entries, so we output them all.
 let
-  throwAfter = n:
+  throwAfter = n: if n > 0 then throwAfter (n - 1) else throw "Uh oh!";
-    if n > 0
-    then throwAfter (n - 1)
-    else throw "Uh oh!";
 in
 throwAfter 2

tests/functional/lang/eval-fail-fetchurl-baseName-attrs-name.nix

@@ -1 +1,4 @@
-builtins.fetchurl { url = "https://example.com/foo.tar.gz"; name = "~wobble~"; }
+builtins.fetchurl {
+  url = "https://example.com/foo.tar.gz";
+  name = "~wobble~";
+}

tests/functional/lang/eval-fail-flake-ref-to-string-negative-integer.nix

@@ -1,7 +1,12 @@
-let n = -1; in builtins.seq n (builtins.flakeRefToString {
+let
+  n = -1;
+in
+builtins.seq n (
+  builtins.flakeRefToString {
     type = "github";
     owner = "NixOS";
     repo = n;
     ref = "23.05";
     dir = "lib";
-})
+  }
+)

tests/functional/lang/eval-fail-foldlStrict-strict-op-application.nix

@@ -1,5 +1,5 @@
 # Tests that the result of applying op is forced even if the value is never used
-builtins.foldl'
+builtins.foldl' (_: f: f null) null [
-  (_: f: f null)
+  (_: throw "Not the final value, but is still forced!")
-  null
+  (_: 23)
-  [ (_: throw "Not the final value, but is still forced!") (_: 23) ]
+]

tests/functional/lang/eval-fail-hashfile-missing.nix

@@ -1,5 +1,16 @@
 let
-  paths = [ ./this-file-is-definitely-not-there-7392097 "/and/neither/is/this/37293620" ];
+  paths = [
+    ./this-file-is-definitely-not-there-7392097
+    "/and/neither/is/this/37293620"
+  ];
 in
-  toString (builtins.concatLists (map (hash: map (builtins.hashFile hash) paths) ["md5" "sha1" "sha256" "sha512"]))
+toString (
-
+  builtins.concatLists (
+    map (hash: map (builtins.hashFile hash) paths) [
+      "md5"
+      "sha1"
+      "sha256"
+      "sha512"
+    ]
+  )
+)

tests/functional/lang/eval-fail-missing-arg.nix

@@ -1 +1,12 @@
-({x, y, z}: x + y + z) {x = "foo"; z = "bar";}
+(
+  {
+    x,
+    y,
+    z,
+  }:
+  x + y + z
+)
+  {
+    x = "foo";
+    z = "bar";
+  }

tests/functional/lang/eval-fail-mutual-recursion.nix

@@ -19,18 +19,22 @@
 # - a few frames of A (skip the rest)
 # - a few frames of B (skip the rest, _and_ skip the remaining frames of A)
 let
-  throwAfterB = recurse: n:
+  throwAfterB =
-    if n > 0
+    recurse: n:
-    then throwAfterB recurse (n - 1)
+    if n > 0 then
-    else if recurse
+      throwAfterB recurse (n - 1)
-    then throwAfterA false 10
+    else if recurse then
-    else throw "Uh oh!";
+      throwAfterA false 10
+    else
+      throw "Uh oh!";
 
-  throwAfterA = recurse: n:
+  throwAfterA =
-    if n > 0
+    recurse: n:
-    then throwAfterA recurse (n - 1)
+    if n > 0 then
-    else if recurse
+      throwAfterA recurse (n - 1)
-    then throwAfterB true 10
+    else if recurse then
-    else throw "Uh oh!";
+      throwAfterB true 10
+    else
+      throw "Uh oh!";
 in
 throwAfterA true 10

tests/functional/lang/eval-fail-nested-list-items.nix

@@ -8,4 +8,27 @@
 #
 #        error: cannot coerce a list to a string: [ [ 1 2 3 4 5 6 7 8 ] [ 1 «4294967290 items elided» ] ]
 
-"" + (let v = [ [ 1 2 3 4 5 6 7 8 ] [1 2 3 4]]; in builtins.deepSeq v v)
+""
++ (
+  let
+    v = [
+      [
+        1
+        2
+        3
+        4
+        5
+        6
+        7
+        8
+      ]
+      [
+        1
+        2
+        3
+        4
+      ]
+    ];
+  in
+  builtins.deepSeq v v
+)