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);
-    fetchTarball {
+  in
-      url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
+  fetchTarball {
-      sha256 = lock.nodes.flake-compat.locked.narHash;
+    url = "https://github.com/edolstra/flake-compat/archive/${lock.nodes.flake-compat.locked.rev}.tar.gz";
-    }
+    sha256 = lock.nodes.flake-compat.locked.narHash;
-  )
+  }
-  { src = ./.; }
+) { src = ./.; }).defaultNix
-).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) "...";
+          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:
-          where *subcommand* is one of the following:
 
-          ${subcommands}
+        ${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 =
-            [ "@store-types@" "./local-store.md" "./local-daemon-store.md" ]
+            replaceStrings
-            [ storesOverview "#local-store" "#local-daemon-store" ]
+              [ "@store-types@" "./local-store.md" "./local-daemon-store.md" ]
-            details.doc;
+              [ 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
+              # Convert each group from a list of key-value pairs back to an attrset
-            (_: listToAttrs)
+              (_: 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 =
-        command = command + " " + subCmd;
+        subCmd:
-        details = details.commands.${subCmd};
+        processCommand {
-        filename = appendName filename subCmd;
+          command = command + " " + subCmd;
-        inherit toplevel;
+          details = details.commands.${subCmd};
-      };
+          filename = appendName filename subCmd;
-    in [ cmd ] ++ concatMap subcommand (attrNames details.commands or {});
+          inherit toplevel;
+        };
+    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,67 +1,99 @@
 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}
+        - ${item}
 
-          ${indent "  " body}
+        ${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}
+        ${experimentalFeatureNote}
 
-          ${description}
+        ${description}
 
-          **Default:** ${showDefault documentDefault defaultValue}
+        **Default:** ${showDefault documentDefault defaultValue}
 
-          ${showAliases aliases}
+        ${showAliases aliases}
-        '';
+      '';
 
       experimentalFeatureNote = optionalString (experimentalFeature != null) ''
-          > **Warning**
+        > **Warning**
-          >
+        >
-          > This setting is part of an
+        > This setting is part of an
-          > [experimental feature](@docroot@/development/experimental-features.md).
+        > [experimental feature](@docroot@/development/experimental-features.md).
-          >
+        >
-          > To change this setting, make sure the
+        > To change this setting, make sure the
-          > [`${experimentalFeature}` experimental feature](@docroot@/development/experimental-features.md#xp-feature-${experimentalFeature})
+        > [`${experimentalFeature}` experimental feature](@docroot@/development/experimental-features.md#xp-feature-${experimentalFeature})
-          > is enabled.
+        > is enabled.
-          > For example, include the following in [`nix.conf`](@docroot@/command-ref/conf-file.md):
+        > For example, include the following in [`nix.conf`](@docroot@/command-ref/conf-file.md):
-          >
+        >
-          > ```
+        > ```
-          > extra-experimental-features = ${experimentalFeature}
+        > extra-experimental-features = ${experimentalFeature}
-          > ${setting} = ...
+        > ${setting} = ...
-          > ```
+        > ```
-        '';
+      '';
 
-      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
+          else if isBool defaultValue then
-              if defaultValue then "`true`" else "`false`"
+            if defaultValue then "`true`" else "`false`"
-            else "`${toString defaultValue}`"
+          else
-        else "*machine-specific*";
+            "`${toString defaultValue}`"
+        else
+          "*machine-specific*";
 
-      showAliases = aliases:
+      showAliases =
-          optionalString (aliases != [])
+        aliases:
-            "**Deprecated alias:** ${(concatStringsSep ", " (map (s: "`${s}`") 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;
-      inherit name;
+    slug = replaceStrings [ " " ] [ "-" ] (toLower name);
-      slug = replaceStrings [ " " ] [ "-" ] (toLower name);
+    filename = "${slug}.md";
-      filename = "${slug}.md";
+    page = showStore { inherit name slug; } storeInfo.${name};
-      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);
+      (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})
-      - [`${name}`](@docroot@/development/experimental-features.md#xp-feature-${name})
+  '';
-    '';
+in
-in xps: indent "  " (concatStrings (attrValues (mapAttrs showExperimentalFeature xps)))
+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
+  # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -25,18 +26,22 @@ mkMesonDerivation (finalAttrs: {
   inherit version;
 
   workDir = ./.;
-  fileset = fileset.difference
+  fileset =
-    (fileset.unions [
+    fileset.difference
-      ../../.version
+      (fileset.unions [
-      # Too many different types of files to filter for now
+        ../../.version
-      ../../doc/manual
+        # Too many different types of files to filter for now
-      ./.
+        ../../doc/manual
-    ])
+        ./.
-    # Do a blacklist instead
+      ])
-    ../../doc/manual/package.nix;
+      # Do a blacklist instead
+      ../../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,11 +59,10 @@ mkMesonDerivation (finalAttrs: {
     nix-cli
   ];
 
-  preConfigure =
+  preConfigure = ''
-    ''
+    chmod u+w ./.version
-      chmod u+w ./.version
+    echo ${finalAttrs.version} > ./.version
-      echo ${finalAttrs.version} > ./.version
+  '';
-    '';
 
   postInstall = ''
     mkdir -p ''$out/nix-support

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"
@@ -22,16 +27,18 @@ rec {
     let
       replaced = replaceStrings [ from ] [ to ] string;
     in
-      if replaced == string then string else replaceStringsRec from to replaced;
+    if replaced == string then string else replaceStringsRec from to replaced;
 
   toLower = replaceStrings upperChars lowerChars;
 
   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 ]) [];
+  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,112 +1,113 @@
-{ 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 =
-    nix
+    with pkgs;
-    bashInteractive
+    [
-    coreutils-full
+      nix
-    gnutar
+      bashInteractive
-    gzip
+      coreutils-full
-    gnugrep
+      gnutar
-    which
+      gzip
-    curl
+      gnugrep
-    less
+      which
-    wget
+      curl
-    man
+      less
-    cacert.out
+      wget
-    findutils
+      man
-    iana-etc
+      cacert.out
-    git
+      findutils
-    openssh
+      iana-etc
-  ] ++ extraPkgs;
+      git
+      openssh
+    ]
+    ++ extraPkgs;
 
-  users = {
+  users =
+    {
 
-    root = {
+      root = {
-      uid = 0;
+        uid = 0;
-      shell = "${pkgs.bashInteractive}/bin/bash";
+        shell = "${pkgs.bashInteractive}/bin/bash";
-      home = "/root";
+        home = "/root";
-      gid = 0;
+        gid = 0;
-      groups = [ "root" ];
+        groups = [ "root" ];
-      description = "System administrator";
+        description = "System administrator";
+      };
+
+      nobody = {
+        uid = 65534;
+        shell = "${pkgs.shadow}/bin/nologin";
+        home = "/var/empty";
+        gid = 65534;
+        groups = [ "nobody" ];
+        description = "Unprivileged account (don't use!)";
+      };
+
+    }
+    // lib.optionalAttrs (uid != 0) {
+      "${uname}" = {
+        uid = uid;
+        shell = "${pkgs.bashInteractive}/bin/bash";
+        home = "/home/${uname}";
+        gid = gid;
+        groups = [ "${gname}" ];
+        description = "Nix user";
+      };
+    }
+    // lib.listToAttrs (
+      map (n: {
+        name = "nixbld${toString n}";
+        value = {
+          uid = 30000 + n;
+          gid = 30000;
+          groups = [ "nixbld" ];
+          description = "Nix build user ${toString n}";
+        };
+      }) (lib.lists.range 1 32)
+    );
+
+  groups =
+    {
+      root.gid = 0;
+      nixbld.gid = 30000;
+      nobody.gid = 65534;
+    }
+    // lib.optionalAttrs (gid != 0) {
+      "${gname}".gid = gid;
     };
 
-    nobody = {
-      uid = 65534;
-      shell = "${pkgs.shadow}/bin/nologin";
-      home = "/var/empty";
-      gid = 65534;
-      groups = [ "nobody" ];
-      description = "Unprivileged account (don't use!)";
-    };
-
-  } // lib.optionalAttrs (uid != 0) {
-    "${uname}" = {
-      uid = uid;
-      shell = "${pkgs.bashInteractive}/bin/bash";
-      home = "/home/${uname}";
-      gid = gid;
-      groups = [ "${gname}" ];
-      description = "Nix user";
-    };
-  } // lib.listToAttrs (
-    map
-      (
-        n: {
-          name = "nixbld${toString n}";
-          value = {
-            uid = 30000 + n;
-            gid = 30000;
-            groups = [ "nixbld" ];
-            description = "Nix build user ${toString n}";
-          };
-        }
-      )
-      (lib.lists.range 1 32)
-  );
-
-  groups = {
-    root.gid = 0;
-    nixbld.gid = 30000;
-    nobody.gid = 65534;
-  } // 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:
-            acc: user:
+          let
-              let
+            groups = users.${user}.groups or [ ];
-                groups = users.${user}.groups or [ ];
+          in
-              in
+          acc
-              acc ++ map
+          ++ map (group: {
-                (group: {
+            inherit user group;
-                  inherit user group;
+          }) groups
-                })
+        ) [ ] (lib.attrNames users)
-                groups
-          )
-          [ ]
-          (lib.attrNames users)
       );
     in
-    (
+    (builtins.foldl' (
-      builtins.foldl'
+      acc: v:
-        (
+      acc
-          acc: v: acc // {
+      // {
-            ${v.group} = acc.${v.group} or [ ] ++ [ v.user ];
+        ${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 =
-    let
+    (lib.concatStringsSep "\n" (
-      vStr = if builtins.isList v then lib.concatStringsSep " " v else v;
+      lib.mapAttrsFlatten (
-    in
+        n: v:
-      "${n} = ${vStr}") (defaultNixConf // nixConf))) + "\n";
+        let
+          vStr = if builtins.isList v then lib.concatStringsSep " " v else v;
+        in
+        "${n} = ${vStr}"
+      ) (defaultNixConf // nixConf)
+    ))
+    + "\n";
 
   userHome = if uid == 0 then "/root" else "/home/${uname}";
 
@@ -184,21 +184,29 @@ let
       manifest = pkgs.buildPackages.runCommand "manifest.nix" { } ''
         cat > $out <<EOF
         [
-        ${lib.concatStringsSep "\n" (builtins.map (drv: let
+        ${lib.concatStringsSep "\n" (
-          outputs = drv.outputsToInstall or [ "out" ];
+          builtins.map (
-        in ''
+            drv:
-          {
+            let
-            ${lib.concatStringsSep "\n" (builtins.map (output: ''
+              outputs = drv.outputsToInstall or [ "out" ];
-              ${output} = { outPath = "${lib.getOutput output drv}"; };
+            in
-            '') outputs)}
+            ''
-            outputs = [ ${lib.concatStringsSep " " (builtins.map (x: "\"${x}\"") outputs)} ];
+              {
-            name = "${drv.name}";
+                ${lib.concatStringsSep "\n" (
-            outPath = "${drv}";
+                  builtins.map (output: ''
-            system = "${drv.system}";
+                    ${output} = { outPath = "${lib.getOutput output drv}"; };
-            type = "derivation";
+                  '') outputs
-            meta = { };
+                )}
-          }
+                outputs = [ ${lib.concatStringsSep " " (builtins.map (x: "\"${x}\"") outputs)} ];
-        '') defaultPkgs)}
+                name = "${drv.name}";
+                outPath = "${drv}";
+                system = "${drv.system}";
+                type = "derivation";
+                meta = { };
+              }
+            ''
+          ) defaultPkgs
+        )}
         ]
         EOF
       '';
@@ -207,16 +215,22 @@ let
         cp -a ${rootEnv}/* $out/
         ln -s ${manifest} $out/manifest.nix
       '';
-      flake-registry-path = if (flake-registry == null) then
+      flake-registry-path =
-        null
+        if (flake-registry == null) then
-      else if (builtins.readFileType (toString flake-registry)) == "directory" then
+          null
-        "${flake-registry}/flake-registry.json"
+        else if (builtins.readFileType (toString flake-registry)) == "directory" then
-      else
+          "${flake-registry}/flake-registry.json"
-        flake-registry;
+        else
+          flake-registry;
     in
     pkgs.runCommand "base-system"
       {
-        inherit passwdContents groupContents shadowContents nixConfContents;
+        inherit
+          passwdContents
+          groupContents
+          shadowContents
+          nixConfContents
+          ;
         passAsFile = [
           "passwdContents"
           "groupContents"
@@ -225,67 +239,79 @@ let
         ];
         allowSubstitutes = false;
         preferLocalBuild = true;
-      } (''
+      }
-      env
+      (
-      set -x
+        ''
-      mkdir -p $out/etc
+          env
+          set -x
+          mkdir -p $out/etc
 
-      mkdir -p $out/etc/ssl/certs
+          mkdir -p $out/etc/ssl/certs
-      ln -s /nix/var/nix/profiles/default/etc/ssl/certs/ca-bundle.crt $out/etc/ssl/certs
+          ln -s /nix/var/nix/profiles/default/etc/ssl/certs/ca-bundle.crt $out/etc/ssl/certs
 
-      cat $passwdContentsPath > $out/etc/passwd
+          cat $passwdContentsPath > $out/etc/passwd
-      echo "" >> $out/etc/passwd
+          echo "" >> $out/etc/passwd
 
-      cat $groupContentsPath > $out/etc/group
+          cat $groupContentsPath > $out/etc/group
-      echo "" >> $out/etc/group
+          echo "" >> $out/etc/group
 
-      cat $shadowContentsPath > $out/etc/shadow
+          cat $shadowContentsPath > $out/etc/shadow
-      echo "" >> $out/etc/shadow
+          echo "" >> $out/etc/shadow
 
-      mkdir -p $out/usr
+          mkdir -p $out/usr
-      ln -s /nix/var/nix/profiles/share $out/usr/
+          ln -s /nix/var/nix/profiles/share $out/usr/
 
-      mkdir -p $out/nix/var/nix/gcroots
+          mkdir -p $out/nix/var/nix/gcroots
 
-      mkdir $out/tmp
+          mkdir $out/tmp
 
-      mkdir -p $out/var/tmp
+          mkdir -p $out/var/tmp
 
-      mkdir -p $out/etc/nix
+          mkdir -p $out/etc/nix
-      cat $nixConfContentsPath > $out/etc/nix/nix.conf
+          cat $nixConfContentsPath > $out/etc/nix/nix.conf
 
-      mkdir -p $out${userHome}
+          mkdir -p $out${userHome}
-      mkdir -p $out/nix/var/nix/profiles/per-user/${uname}
+          mkdir -p $out/nix/var/nix/profiles/per-user/${uname}
 
-      ln -s ${profile} $out/nix/var/nix/profiles/default-1-link
+          ln -s ${profile} $out/nix/var/nix/profiles/default-1-link
-      ln -s /nix/var/nix/profiles/default-1-link $out/nix/var/nix/profiles/default
+          ln -s /nix/var/nix/profiles/default-1-link $out/nix/var/nix/profiles/default
-      ln -s /nix/var/nix/profiles/default $out${userHome}/.nix-profile
+          ln -s /nix/var/nix/profiles/default $out${userHome}/.nix-profile
 
-      ln -s ${channel} $out/nix/var/nix/profiles/per-user/${uname}/channels-1-link
+          ln -s ${channel} $out/nix/var/nix/profiles/per-user/${uname}/channels-1-link
-      ln -s /nix/var/nix/profiles/per-user/${uname}/channels-1-link $out/nix/var/nix/profiles/per-user/${uname}/channels
+          ln -s /nix/var/nix/profiles/per-user/${uname}/channels-1-link $out/nix/var/nix/profiles/per-user/${uname}/channels
 
-      mkdir -p $out${userHome}/.nix-defexpr
+          mkdir -p $out${userHome}/.nix-defexpr
-      ln -s /nix/var/nix/profiles/per-user/${uname}/channels $out${userHome}/.nix-defexpr/channels
+          ln -s /nix/var/nix/profiles/per-user/${uname}/channels $out${userHome}/.nix-defexpr/channels
-      echo "${channelURL} ${channelName}" > $out${userHome}/.nix-channels
+          echo "${channelURL} ${channelName}" > $out${userHome}/.nix-channels
 
-      mkdir -p $out/bin $out/usr/bin
+          mkdir -p $out/bin $out/usr/bin
-      ln -s ${pkgs.coreutils}/bin/env $out/usr/bin/env
+          ln -s ${pkgs.coreutils}/bin/env $out/usr/bin/env
-      ln -s ${pkgs.bashInteractive}/bin/bash $out/bin/sh
+          ln -s ${pkgs.bashInteractive}/bin/bash $out/bin/sh
 
-    '' + (lib.optionalString (flake-registry-path != null) ''
+        ''
-      nixCacheDir="${userHome}/.cache/nix"
+        + (lib.optionalString (flake-registry-path != null) ''
-      mkdir -p $out$nixCacheDir
+          nixCacheDir="${userHome}/.cache/nix"
-      globalFlakeRegistryPath="$nixCacheDir/flake-registry.json"
+          mkdir -p $out$nixCacheDir
-      ln -s ${flake-registry-path} $out$globalFlakeRegistryPath
+          globalFlakeRegistryPath="$nixCacheDir/flake-registry.json"
-      mkdir -p $out/nix/var/nix/gcroots/auto
+          ln -s ${flake-registry-path} $out$globalFlakeRegistryPath
-      rootName=$(${pkgs.nix}/bin/nix --extra-experimental-features nix-command hash file --type sha1 --base32 <(echo -n $globalFlakeRegistryPath))
+          mkdir -p $out/nix/var/nix/gcroots/auto
-      ln -s $globalFlakeRegistryPath $out/nix/var/nix/gcroots/auto/$rootName
+          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=${
-        "${userHome}/.nix-profile/bin"
+        lib.concatStringsSep ":" [
-        "/nix/var/nix/profiles/default/bin"
+          "${userHome}/.nix-profile/bin"
-        "/nix/var/nix/profiles/default/sbin"
+          "/nix/var/nix/profiles/default/bin"
-      ]}"
+          "/nix/var/nix/profiles/default/sbin"
-      "MANPATH=${lib.concatStringsSep ":" [
+        ]
-        "${userHome}/.nix-profile/share/man"
+      }"
-        "/nix/var/nix/profiles/default/share/man"
+      "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 = [
@@ -60,7 +74,7 @@
         (Provided that the names are unique.)
 
         See https://nixos.org/manual/nixpkgs/stable/index.html#function-library-lib.attrsets.concatMapAttrs
-       */
+      */
       flatMapAttrs = attrs: f: lib.concatMapAttrs f attrs;
 
       forAllSystems = lib.genAttrs systems;
@@ -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 =
-          _module.args.pkgs = nixpkgsFor.${system}.native;
+          { 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 =
-              localSystem = {
+            crossSystem:
-                inherit system;
+            forAllStdenvs (
-              };
+              stdenv:
-              crossSystem = if crossSystem == null then null else {
+              import nixpkgs {
-                config = crossSystem;
+                localSystem = {
-              } // lib.optionalAttrs (crossSystem == "x86_64-unknown-freebsd13") {
+                  inherit system;
-                useLLVM = true;
+                };
-              };
+                crossSystem =
-              overlays = [
+                  if crossSystem == null then
-                (overlayFor (pkgs: pkgs.${stdenv}))
+                    null
-              ];
+                  else
-            });
+                    {
-        in rec {
+                      config = crossSystem;
+                    }
+                    // lib.optionalAttrs (crossSystem == "x86_64-unknown-freebsd13") {
+                      useLLVM = true;
+                    };
+                overlays = [
+                  (overlayFor (pkgs: pkgs.${stdenv}))
+                ];
+              }
+            );
+        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,53 +210,69 @@
           ;
       };
 
-      checks = forAllSystems (system: {
+      checks = forAllSystems (
-        installerScriptForGHA = self.hydraJobs.installerScriptForGHA.${system};
+        system:
-        installTests = self.hydraJobs.installTests.${system};
+        {
-        nixpkgsLibTests = self.hydraJobs.tests.nixpkgsLibTests.${system};
+          installerScriptForGHA = self.hydraJobs.installerScriptForGHA.${system};
-        rl-next =
+          installTests = self.hydraJobs.installTests.${system};
-          let pkgs = nixpkgsFor.${system}.native;
+          nixpkgsLibTests = self.hydraJobs.tests.nixpkgsLibTests.${system};
-          in pkgs.buildPackages.runCommand "test-rl-next-release-notes" { } ''
+          rl-next =
-          LANG=C.UTF-8 ${pkgs.changelog-d}/bin/changelog-d ${./doc/manual/rl-next} >$out
+            let
-        '';
+              pkgs = nixpkgsFor.${system}.native;
-        repl-completion = nixpkgsFor.${system}.native.callPackage ./tests/repl-completion.nix { };
+            in
-      } // (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
+            pkgs.buildPackages.runCommand "test-rl-next-release-notes" { } ''
-        dockerImage = self.hydraJobs.dockerImage.${system};
+              LANG=C.UTF-8 ${pkgs.changelog-d}/bin/changelog-d ${./doc/manual/rl-next} >$out
-      } // (lib.optionalAttrs (!(builtins.elem system linux32BitSystems))) {
+            '';
-        # Some perl dependencies are broken on i686-linux.
+          repl-completion = nixpkgsFor.${system}.native.callPackage ./tests/repl-completion.nix { };
-        # Since the support is only best-effort there, disable the perl
+        }
-        # bindings
+        // (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
-        perlBindings = self.hydraJobs.perlBindings.${system};
+          dockerImage = self.hydraJobs.dockerImage.${system};
-      }
+        }
-      # Add "passthru" tests
+        // (lib.optionalAttrs (!(builtins.elem system linux32BitSystems))) {
-      // flatMapAttrs ({
+          # Some perl dependencies are broken on i686-linux.
-          "" = nixpkgsFor.${system}.native;
+          # Since the support is only best-effort there, disable the perl
-        } // lib.optionalAttrs (! nixpkgsFor.${system}.native.stdenv.hostPlatform.isDarwin) {
+          # bindings
-          # TODO: enable static builds for darwin, blocked on:
+          perlBindings = self.hydraJobs.perlBindings.${system};
-          #       https://github.com/NixOS/nixpkgs/issues/320448
+        }
-          # TODO: disabled to speed up GHA CI.
+        # Add "passthru" tests
-          #"static-" = nixpkgsFor.${system}.native.pkgsStatic;
+        //
-        })
+          flatMapAttrs
-        (nixpkgsPrefix: nixpkgs:
+            (
-          flatMapAttrs nixpkgs.nixComponents
+              {
-            (pkgName: pkg:
+                "" = nixpkgsFor.${system}.native;
-              flatMapAttrs pkg.tests or {}
+              }
-              (testName: test: {
+              // lib.optionalAttrs (!nixpkgsFor.${system}.native.stdenv.hostPlatform.isDarwin) {
-                "${nixpkgsPrefix}${pkgName}-${testName}" = test;
+                # 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;
+              }
             )
-          // lib.optionalAttrs (nixpkgs.stdenv.hostPlatform == nixpkgs.stdenv.buildPlatform) {
+            (
-            "${nixpkgsPrefix}nix-functional-tests" = nixpkgs.nixComponents.nix-functional-tests;
+              nixpkgsPrefix: nixpkgs:
-          }
+              flatMapAttrs nixpkgs.nixComponents (
-        )
+                pkgName: pkg:
-      // devFlake.checks.${system} or {}
+                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;
+              }
+            )
+        // 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,97 +283,144 @@
           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
-            "nix-util" = { };
+            {
-            "nix-util-c" = { };
+              # Components we'll iterate over in the upcoming lambda
-            "nix-util-test-support" = { };
+              "nix-util" = { };
-            "nix-util-tests" = { };
+              "nix-util-c" = { };
+              "nix-util-test-support" = { };
+              "nix-util-tests" = { };
 
-            "nix-store" = { };
+              "nix-store" = { };
-            "nix-store-c" = { };
+              "nix-store-c" = { };
-            "nix-store-test-support" = { };
+              "nix-store-test-support" = { };
-            "nix-store-tests" = { };
+              "nix-store-tests" = { };
 
-            "nix-fetchers" = { };
+              "nix-fetchers" = { };
-            "nix-fetchers-tests" = { };
+              "nix-fetchers-tests" = { };
 
-            "nix-expr" = { };
+              "nix-expr" = { };
-            "nix-expr-c" = { };
+              "nix-expr-c" = { };
-            "nix-expr-test-support" = { };
+              "nix-expr-test-support" = { };
-            "nix-expr-tests" = { };
+              "nix-expr-tests" = { };
 
-            "nix-flake" = { };
+              "nix-flake" = { };
-            "nix-flake-tests" = { };
+              "nix-flake-tests" = { };
 
-            "nix-main" = { };
+              "nix-main" = { };
-            "nix-main-c" = { };
+              "nix-main-c" = { };
 
-            "nix-cmd" = { };
+              "nix-cmd" = { };
 
-            "nix-cli" = { };
+              "nix-cli" = { };
 
-            "nix-everything" = { };
+              "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 }: {
+              };
-              # 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: {}: {
+            (
-              # These attributes go right into `packages.<system>`.
+              pkgName:
-              "${pkgName}-${crossSystem}" = nixpkgsFor.${system}.cross.${crossSystem}.nixComponents.${pkgName};
+              {
-            }))
+                supportsCross ? true,
-            // flatMapAttrs (lib.genAttrs stdenvs (_: { })) (stdenvName: {}: {
+              }:
-              # These attributes go right into `packages.<system>`.
+              {
-              "${pkgName}-${stdenvName}" = nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.nixComponents.${pkgName};
+                # 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:
+                  { }:
+                  {
+                    # These attributes go right into `packages.<system>`.
+                    "${pkgName}-${crossSystem}" = nixpkgsFor.${system}.cross.${crossSystem}.nixComponents.${pkgName};
+                  }
+                )
+              )
+              // flatMapAttrs (lib.genAttrs stdenvs (_: { })) (
+                stdenvName:
+                { }:
+                {
+                  # These attributes go right into `packages.<system>`.
+                  "${pkgName}-${stdenvName}" =
+                    nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.nixComponents.${pkgName};
+                }
+              )
+            )
         // lib.optionalAttrs (builtins.elem system linux64BitSystems) {
-        dockerImage =
+          dockerImage =
-          let
+            let
-            pkgs = nixpkgsFor.${system}.native;
+              pkgs = nixpkgsFor.${system}.native;
-            image = import ./docker.nix { inherit pkgs; tag = pkgs.nix.version; };
+              image = import ./docker.nix {
-          in
+                inherit pkgs;
-          pkgs.runCommand
+                tag = pkgs.nix.version;
-            "docker-image-tarball-${pkgs.nix.version}"
+              };
-            { meta.description = "Docker image with Nix for ${system}"; }
+            in
-            ''
+            pkgs.runCommand "docker-image-tarball-${pkgs.nix.version}"
-              mkdir -p $out/nix-support
+              { meta.description = "Docker image with Nix for ${system}"; }
-              image=$out/image.tar.gz
+              ''
-              ln -s ${image} $image
+                mkdir -p $out/nix-support
-              echo "file binary-dist $image" >> $out/nix-support/hydra-build-products
+                image=$out/image.tar.gz
-            '';
+                ln -s ${image} $image
-      });
+                echo "file binary-dist $image" >> $out/nix-support/hydra-build-products
+              '';
+        }
+      );
 
-      devShells = let
+      devShells =
-        makeShell = import ./packaging/dev-shell.nix { inherit inputs lib devFlake; };
+        let
-        prefixAttrs = prefix: lib.concatMapAttrs (k: v: { "${prefix}-${k}" = v; });
+          makeShell = import ./packaging/dev-shell.nix { inherit inputs lib devFlake; };
-      in
+          prefixAttrs = prefix: lib.concatMapAttrs (k: v: { "${prefix}-${k}" = v; });
-        forAllSystems (system:
+        in
-          prefixAttrs "native" (forAllStdenvs (stdenvName: makeShell {
+        forAllSystems (
-            pkgs = nixpkgsFor.${system}.nativeForStdenv.${stdenvName};
+          system:
-          })) //
+          prefixAttrs "native" (
-          lib.optionalAttrs (!nixpkgsFor.${system}.native.stdenv.isDarwin) (
+            forAllStdenvs (
-            prefixAttrs "static" (forAllStdenvs (stdenvName: makeShell {
+              stdenvName:
-              pkgs = nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.pkgsStatic;
+              makeShell {
-            })) //
+                pkgs = nixpkgsFor.${system}.nativeForStdenv.${stdenvName};
-            prefixAttrs "llvm" (forAllStdenvs (stdenvName: makeShell {
+              }
-              pkgs = nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.pkgsLLVM;
+            )
-            })) //
+          )
-            prefixAttrs "cross" (forAllCrossSystems (crossSystem: makeShell {
+          // lib.optionalAttrs (!nixpkgsFor.${system}.native.stdenv.isDarwin) (
-              pkgs = nixpkgsFor.${system}.cross.${crossSystem};
+            prefixAttrs "static" (
-            }))
+              forAllStdenvs (
-          ) //
+                stdenvName:
-          {
+                makeShell {
+                  pkgs = nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.pkgsStatic;
+                }
+              )
+            )
+            // prefixAttrs "llvm" (
+              forAllStdenvs (
+                stdenvName:
+                makeShell {
+                  pkgs = nixpkgsFor.${system}.nativeForStdenv.${stdenvName}.pkgsLLVM;
+                }
+              )
+            )
+            // prefixAttrs "cross" (
+              forAllCrossSystems (
+                crossSystem:
+                makeShell {
+                  pkgs = nixpkgsFor.${system}.cross.${crossSystem};
+                }
+              )
+            )
+          )
+          // {
             native = self.devShells.${system}.native-stdenv;
             default = self.devShells.${system}.native;
           }
         );
-  };
+    };
 }

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,117 +70,129 @@ let
       workDir = null;
     };
 
-  mesonLayer = finalAttrs: prevAttrs:
+  mesonLayer = finalAttrs: prevAttrs: {
-    {
+    # NOTE:
-      # NOTE:
+    # As of https://github.com/NixOS/nixpkgs/blob/8baf8241cea0c7b30e0b8ae73474cb3de83c1a30/pkgs/by-name/me/meson/setup-hook.sh#L26,
-      # 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.
-      # `mesonBuildType` defaults to `plain` if not specified. We want our Nix-built binaries to be optimized by default.
+    # More on build types here: https://mesonbuild.com/Builtin-options.html#details-for-buildtype.
-      # More on build types here: https://mesonbuild.com/Builtin-options.html#details-for-buildtype.
+    mesonBuildType = "release";
-      mesonBuildType = "release";
+    # NOTE:
-      # NOTE:
+    # Users who are debugging Nix builds are expected to set the environment variable `mesonBuildType`, per the
-      # 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.
-      # 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.
-      # For this reason, we don't want to refer to `finalAttrs.mesonBuildType` here, but rather use the environment variable.
+    preConfigure =
-      preConfigure = prevAttrs.preConfigure or "" + lib.optionalString (
+      prevAttrs.preConfigure or ""
-        !stdenv.hostPlatform.isWindows
+      +
-        # build failure
+        lib.optionalString
-        && !stdenv.hostPlatform.isStatic
+          (
-        # LTO breaks exception handling on x86-64-darwin.
+            !stdenv.hostPlatform.isWindows
-        && stdenv.system != "x86_64-darwin"
+            # build failure
-      ) ''
+            && !stdenv.hostPlatform.isStatic
-        case "$mesonBuildType" in
+            # LTO breaks exception handling on x86-64-darwin.
-        release|minsize) appendToVar mesonFlags "-Db_lto=true"  ;;
+            && stdenv.system != "x86_64-darwin"
-        *)               appendToVar mesonFlags "-Db_lto=false" ;;
+          )
-        esac
+          ''
-      '';
+            case "$mesonBuildType" in
-      nativeBuildInputs = [
+            release|minsize) appendToVar mesonFlags "-Db_lto=true"  ;;
-        pkgs.buildPackages.meson
+            *)               appendToVar mesonFlags "-Db_lto=false" ;;
-        pkgs.buildPackages.ninja
+            esac
-      ] ++ prevAttrs.nativeBuildInputs or [];
+          '';
-      mesonCheckFlags = prevAttrs.mesonCheckFlags or [] ++ [
+    nativeBuildInputs = [
-        "--print-errorlogs"
+      pkgs.buildPackages.meson
-      ];
+      pkgs.buildPackages.ninja
-    };
+    ] ++ prevAttrs.nativeBuildInputs or [ ];
+    mesonCheckFlags = prevAttrs.mesonCheckFlags or [ ] ++ [
+      "--print-errorlogs"
+    ];
+  };
 
-  mesonBuildLayer = finalAttrs: prevAttrs:
+  mesonBuildLayer = finalAttrs: prevAttrs: {
-    {
+    nativeBuildInputs = prevAttrs.nativeBuildInputs or [ ] ++ [
-      nativeBuildInputs = prevAttrs.nativeBuildInputs or [] ++ [
+      pkgs.buildPackages.pkg-config
-        pkgs.buildPackages.pkg-config
+    ];
-      ];
+    separateDebugInfo = !stdenv.hostPlatform.isStatic;
-      separateDebugInfo = !stdenv.hostPlatform.isStatic;
+    hardeningDisable = lib.optional stdenv.hostPlatform.isStatic "pie";
-      hardeningDisable = lib.optional stdenv.hostPlatform.isStatic "pie";
+    env =
-      env = prevAttrs.env or {}
+      prevAttrs.env or { }
-        // lib.optionalAttrs
+      // lib.optionalAttrs (
-          (stdenv.isLinux
+        stdenv.isLinux
-            && !(stdenv.hostPlatform.isStatic && stdenv.system == "aarch64-linux")
+        && !(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" ];
-      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 [];
+      mesonFlags = [ (lib.mesonBool "b_asneeded" false) ] ++ prevAttrs.mesonFlags or [ ];
     };
 
-  miscGoodPractice = finalAttrs: prevAttrs:
+  miscGoodPractice = finalAttrs: prevAttrs: {
-    {
+    strictDeps = prevAttrs.strictDeps or true;
-      strictDeps = prevAttrs.strictDeps or true;
+    enableParallelBuilding = true;
-      enableParallelBuilding = true;
+  };
-    };
 in
 scope: {
   inherit stdenv;
 
-  aws-sdk-cpp = (pkgs.aws-sdk-cpp.override {
+  aws-sdk-cpp =
-    apis = [ "s3" "transfer" ];
+    (pkgs.aws-sdk-cpp.override {
-    customMemoryManagement = false;
+      apis = [
-  }).overrideAttrs {
+        "s3"
-    # only a stripped down version is built, which takes a lot less resources
+        "transfer"
-    # to build, so we don't need a "big-parallel" machine.
+      ];
-    requiredSystemFeatures = [ ];
+      customMemoryManagement = false;
-  };
+    }).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 = [ ];
+      };
 
   boehmgc = pkgs.boehmgc.override {
     enableLargeConfig = true;
   };
 
   # TODO Hack until https://github.com/NixOS/nixpkgs/issues/45462 is fixed.
-  boost = (pkgs.boost.override {
+  boost =
-    extraB2Args = [
+    (pkgs.boost.override {
-      "--with-container"
+      extraB2Args = [
-      "--with-context"
+        "--with-container"
-      "--with-coroutine"
+        "--with-context"
-    ];
+        "--with-coroutine"
-  }).overrideAttrs (old: {
+      ];
-    # Need to remove `--with-*` to use `--with-libraries=...`
+    }).overrideAttrs
-    buildPhase = lib.replaceStrings [ "--without-python" ] [ "" ] old.buildPhase;
+      (old: {
-    installPhase = lib.replaceStrings [ "--without-python" ] [ "" ] old.installPhase;
+        # 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,27 +206,24 @@ scope: {
 
   inherit resolvePath filesetToSource;
 
-  mkMesonDerivation =
+  mkMesonDerivation = mkPackageBuilder [
-    mkPackageBuilder [
+    miscGoodPractice
-      miscGoodPractice
+    localSourceLayer
-      localSourceLayer
+    mesonLayer
-      mesonLayer
+  ];
-    ];
+  mkMesonExecutable = mkPackageBuilder [
-  mkMesonExecutable =
+    miscGoodPractice
-    mkPackageBuilder [
+    bsdNoLinkAsNeeded
-      miscGoodPractice
+    localSourceLayer
-      bsdNoLinkAsNeeded
+    mesonLayer
-      localSourceLayer
+    mesonBuildLayer
-      mesonLayer
+  ];
-      mesonBuildLayer
+  mkMesonLibrary = mkPackageBuilder [
-    ];
+    miscGoodPractice
-  mkMesonLibrary =
+    bsdNoLinkAsNeeded
-    mkPackageBuilder [
+    localSourceLayer
-      miscGoodPractice
+    mesonLayer
-      bsdNoLinkAsNeeded
+    mesonBuildLayer
-      localSourceLayer
+    mesonLibraryLayer
-      mesonLayer
+  ];
-      mesonBuildLayer
-      mesonLibraryLayer
-    ];
 }

packaging/dev-shell.nix

@@ -1,129 +1,141 @@
-{ lib, inputs, devFlake }:
+{
+  lib,
+  inputs,
+  devFlake,
+}:
 
 { pkgs }:
 
-pkgs.nixComponents.nix-util.overrideAttrs (attrs:
+pkgs.nixComponents.nix-util.overrideAttrs (
+  attrs:
 
-let
+  let
-  stdenv = pkgs.nixDependencies.stdenv;
+    stdenv = pkgs.nixDependencies.stdenv;
-  buildCanExecuteHost = stdenv.buildPlatform.canExecute stdenv.hostPlatform;
+    buildCanExecuteHost = stdenv.buildPlatform.canExecute stdenv.hostPlatform;
-  modular = devFlake.getSystem stdenv.buildPlatform.system;
+    modular = devFlake.getSystem stdenv.buildPlatform.system;
-  transformFlag = prefix: flag:
+    transformFlag =
-    assert builtins.isString flag;
+      prefix: flag:
-    let
+      assert builtins.isString flag;
-      rest = builtins.substring 2 (builtins.stringLength flag) flag;
+      let
-    in
+        rest = builtins.substring 2 (builtins.stringLength flag) flag;
+      in
       "-D${prefix}:${rest}";
-  havePerl = stdenv.buildPlatform == stdenv.hostPlatform && stdenv.hostPlatform.isUnix;
+    havePerl = stdenv.buildPlatform == stdenv.hostPlatform && stdenv.hostPlatform.isUnix;
-  ignoreCrossFile = flags: builtins.filter (flag: !(lib.strings.hasInfix "cross-file" flag)) flags;
+    ignoreCrossFile = flags: builtins.filter (flag: !(lib.strings.hasInfix "cross-file" flag)) flags;
-in {
+  in
-  pname = "shell-for-" + attrs.pname;
+  {
+    pname = "shell-for-" + attrs.pname;
 
-  # Remove the version suffix to avoid unnecessary attempts to substitute in nix develop
+    # Remove the version suffix to avoid unnecessary attempts to substitute in nix develop
-  version = lib.fileContents ../.version;
+    version = lib.fileContents ../.version;
-  name = attrs.pname;
+    name = attrs.pname;
 
-  installFlags = "sysconfdir=$(out)/etc";
+    installFlags = "sysconfdir=$(out)/etc";
-  shellHook = ''
+    shellHook = ''
-    PATH=$prefix/bin:$PATH
+      PATH=$prefix/bin:$PATH
-    unset PYTHONPATH
+      unset PYTHONPATH
-    export MANPATH=$out/share/man:$MANPATH
+      export MANPATH=$out/share/man:$MANPATH
 
-    # Make bash completion work.
+      # Make bash completion work.
-    XDG_DATA_DIRS+=:$out/share
+      XDG_DATA_DIRS+=:$out/share
 
-    # Make the default phases do the right thing.
+      # Make the default phases do the right thing.
-    # FIXME: this wouldn't be needed if the ninja package set buildPhase() instead of $buildPhase.
+      # FIXME: this wouldn't be needed if the ninja package set buildPhase() instead of $buildPhase.
-    # FIXME: mesonConfigurePhase shouldn't cd to the build directory. It would be better to pass '-C <dir>' to ninja.
+      # FIXME: mesonConfigurePhase shouldn't cd to the build directory. It would be better to pass '-C <dir>' to ninja.
 
-    cdToBuildDir() {
+      cdToBuildDir() {
-        if [[ ! -e build.ninja ]]; then
+          if [[ ! -e build.ninja ]]; then
-            cd build
+              cd build
-        fi
+          fi
-    }
+      }
 
-    configurePhase() {
+      configurePhase() {
-        mesonConfigurePhase
+          mesonConfigurePhase
-    }
+      }
 
-    buildPhase() {
+      buildPhase() {
-        cdToBuildDir
+          cdToBuildDir
-        ninjaBuildPhase
+          ninjaBuildPhase
-    }
+      }
 
-    checkPhase() {
+      checkPhase() {
-        cdToBuildDir
+          cdToBuildDir
-        mesonCheckPhase
+          mesonCheckPhase
-    }
+      }
 
-    installPhase() {
+      installPhase() {
-        cdToBuildDir
+          cdToBuildDir
-        ninjaInstallPhase
+          ninjaInstallPhase
-    }
+      }
-  '';
+    '';
 
-  # We use this shell with the local checkout, not unpackPhase.
+    # We use this shell with the local checkout, not unpackPhase.
-  src = null;
+    src = null;
 
-  env = {
+    env = {
-    # Needed for Meson to find Boost.
+      # Needed for Meson to find Boost.
-    # https://github.com/NixOS/nixpkgs/issues/86131.
+      # https://github.com/NixOS/nixpkgs/issues/86131.
-    BOOST_INCLUDEDIR = "${lib.getDev pkgs.nixDependencies.boost}/include";
+      BOOST_INCLUDEDIR = "${lib.getDev pkgs.nixDependencies.boost}/include";
-    BOOST_LIBRARYDIR = "${lib.getLib pkgs.nixDependencies.boost}/lib";
+      BOOST_LIBRARYDIR = "${lib.getLib pkgs.nixDependencies.boost}/lib";
-    # For `make format`, to work without installing pre-commit
+      # 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 =
+    mesonFlags =
-    map (transformFlag "libutil") (ignoreCrossFile pkgs.nixComponents.nix-util.mesonFlags)
+      map (transformFlag "libutil") (ignoreCrossFile pkgs.nixComponents.nix-util.mesonFlags)
-    ++ map (transformFlag "libstore") (ignoreCrossFile pkgs.nixComponents.nix-store.mesonFlags)
+      ++ map (transformFlag "libstore") (ignoreCrossFile pkgs.nixComponents.nix-store.mesonFlags)
-    ++ map (transformFlag "libfetchers") (ignoreCrossFile pkgs.nixComponents.nix-fetchers.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 "libexpr") (ignoreCrossFile pkgs.nixComponents.nix-expr.mesonFlags)
+        map (transformFlag "perl") (ignoreCrossFile pkgs.nixComponents.nix-perl-bindings.mesonFlags)
-    ++ map (transformFlag "libcmd") (ignoreCrossFile pkgs.nixComponents.nix-cmd.mesonFlags)
+      )
-    ;
+      ++ map (transformFlag "libexpr") (ignoreCrossFile pkgs.nixComponents.nix-expr.mesonFlags)
+      ++ map (transformFlag "libcmd") (ignoreCrossFile pkgs.nixComponents.nix-cmd.mesonFlags);
 
-  nativeBuildInputs = attrs.nativeBuildInputs or []
+    nativeBuildInputs =
-    ++ pkgs.nixComponents.nix-util.nativeBuildInputs
+      attrs.nativeBuildInputs or [ ]
-    ++ pkgs.nixComponents.nix-store.nativeBuildInputs
+      ++ pkgs.nixComponents.nix-util.nativeBuildInputs
-    ++ pkgs.nixComponents.nix-fetchers.nativeBuildInputs
+      ++ pkgs.nixComponents.nix-store.nativeBuildInputs
-    ++ pkgs.nixComponents.nix-expr.nativeBuildInputs
+      ++ pkgs.nixComponents.nix-fetchers.nativeBuildInputs
-    ++ lib.optionals havePerl pkgs.nixComponents.nix-perl-bindings.nativeBuildInputs
+      ++ pkgs.nixComponents.nix-expr.nativeBuildInputs
-    ++ lib.optionals buildCanExecuteHost pkgs.nixComponents.nix-manual.externalNativeBuildInputs
+      ++ lib.optionals havePerl pkgs.nixComponents.nix-perl-bindings.nativeBuildInputs
-    ++ pkgs.nixComponents.nix-internal-api-docs.nativeBuildInputs
+      ++ lib.optionals buildCanExecuteHost pkgs.nixComponents.nix-manual.externalNativeBuildInputs
-    ++ pkgs.nixComponents.nix-external-api-docs.nativeBuildInputs
+      ++ pkgs.nixComponents.nix-internal-api-docs.nativeBuildInputs
-    ++ pkgs.nixComponents.nix-functional-tests.externalNativeBuildInputs
+      ++ pkgs.nixComponents.nix-external-api-docs.nativeBuildInputs
-    ++ lib.optional
+      ++ pkgs.nixComponents.nix-functional-tests.externalNativeBuildInputs
-      (!buildCanExecuteHost
+      ++ lib.optional (
-         # Hack around https://github.com/nixos/nixpkgs/commit/bf7ad8cfbfa102a90463433e2c5027573b462479
+        !buildCanExecuteHost
-         && !(stdenv.hostPlatform.isWindows && stdenv.buildPlatform.isDarwin)
+        # Hack around https://github.com/nixos/nixpkgs/commit/bf7ad8cfbfa102a90463433e2c5027573b462479
-         && stdenv.hostPlatform.emulatorAvailable pkgs.buildPackages
+        && !(stdenv.hostPlatform.isWindows && stdenv.buildPlatform.isDarwin)
-         && lib.meta.availableOn stdenv.buildPlatform (stdenv.hostPlatform.emulator pkgs.buildPackages))
+        && stdenv.hostPlatform.emulatorAvailable pkgs.buildPackages
-      pkgs.buildPackages.mesonEmulatorHook
+        && lib.meta.availableOn stdenv.buildPlatform (stdenv.hostPlatform.emulator pkgs.buildPackages)
-    ++ [
+      ) pkgs.buildPackages.mesonEmulatorHook
-      pkgs.buildPackages.cmake
+      ++ [
-      pkgs.buildPackages.shellcheck
+        pkgs.buildPackages.cmake
-      pkgs.buildPackages.changelog-d
+        pkgs.buildPackages.shellcheck
-      modular.pre-commit.settings.package
+        pkgs.buildPackages.changelog-d
-      (pkgs.writeScriptBin "pre-commit-hooks-install"
+        modular.pre-commit.settings.package
-        modular.pre-commit.settings.installationScript)
+        (pkgs.writeScriptBin "pre-commit-hooks-install" modular.pre-commit.settings.installationScript)
-      inputs.nixfmt.packages.${pkgs.hostPlatform.system}.default
+        inputs.nixfmt.packages.${pkgs.hostPlatform.system}.default
-    ]
+      ]
-    # TODO: Remove the darwin check once
+      # TODO: Remove the darwin check once
-    # https://github.com/NixOS/nixpkgs/pull/291814 is available
+      # 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.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 =
-    ++ pkgs.nixComponents.nix-util.buildInputs
+      attrs.buildInputs or [ ]
-    ++ pkgs.nixComponents.nix-store.buildInputs
+      ++ pkgs.nixComponents.nix-util.buildInputs
-    ++ pkgs.nixComponents.nix-store-tests.externalBuildInputs
+      ++ pkgs.nixComponents.nix-store.buildInputs
-    ++ pkgs.nixComponents.nix-fetchers.buildInputs
+      ++ pkgs.nixComponents.nix-store-tests.externalBuildInputs
-    ++ pkgs.nixComponents.nix-expr.buildInputs
+      ++ pkgs.nixComponents.nix-fetchers.buildInputs
-    ++ pkgs.nixComponents.nix-expr.externalPropagatedBuildInputs
+      ++ pkgs.nixComponents.nix-expr.buildInputs
-    ++ pkgs.nixComponents.nix-cmd.buildInputs
+      ++ pkgs.nixComponents.nix-expr.externalPropagatedBuildInputs
-    ++ lib.optionals havePerl pkgs.nixComponents.nix-perl-bindings.externalBuildInputs
+      ++ pkgs.nixComponents.nix-cmd.buildInputs
-    ++ lib.optional havePerl pkgs.perl
+      ++ lib.optionals havePerl pkgs.nixComponents.nix-perl-bindings.externalBuildInputs
-    ;
+      ++ lib.optional havePerl pkgs.perl;
-})
+  }
+)

packaging/everything.nix

@@ -42,27 +42,31 @@
 }:
 
 let
-  libs = {
+  libs =
-    inherit
+    {
-      nix-util
+      inherit
-      nix-util-c
+        nix-util
-      nix-store
+        nix-util-c
-      nix-store-c
+        nix-store
-      nix-fetchers
+        nix-store-c
-      nix-expr
+        nix-fetchers
-      nix-expr-c
+        nix-expr
-      nix-flake
+        nix-expr-c
-      nix-flake-c
+        nix-flake
-      nix-main
+        nix-flake-c
-      nix-main-c
+        nix-main
-      nix-cmd
+        nix-main-c
-    ;
+        nix-cmd
-  } // lib.optionalAttrs (!stdenv.hostPlatform.isStatic && stdenv.buildPlatform.canExecute stdenv.hostPlatform) {
+        ;
-    # Currently fails in static build
+    }
-    inherit
+    // lib.optionalAttrs
-      nix-perl-bindings
+      (!stdenv.hostPlatform.isStatic && stdenv.buildPlatform.canExecute stdenv.hostPlatform)
-    ;
+      {
-  };
+        # Currently fails in static build
+        inherit
+          nix-perl-bindings
+          ;
+      };
 
   dev = stdenv.mkDerivation (finalAttrs: {
     name = "nix-${nix-cli.version}-dev";
@@ -77,10 +81,9 @@ let
     '';
     passthru = {
       tests = {
-        pkg-config =
+        pkg-config = testers.hasPkgConfigModules {
-          testers.hasPkgConfigModules {
+          package = finalAttrs.finalPackage;
-            package = finalAttrs.finalPackage;
+        };
-          };
       };
 
       # If we were to fully emulate output selection here, we'd confuse the Nix CLIs,
@@ -123,70 +126,84 @@ in
   ];
 
   meta.mainProgram = "nix";
-}).overrideAttrs (finalAttrs: prevAttrs: {
+}).overrideAttrs
-  doCheck = true;
+  (
-  doInstallCheck = true;
+    finalAttrs: prevAttrs: {
+      doCheck = true;
+      doInstallCheck = true;
 
-  checkInputs = [
+      checkInputs =
-    # Make sure the unit tests have passed
+        [
-    nix-util-tests.tests.run
+          # Make sure the unit tests have passed
-    nix-store-tests.tests.run
+          nix-util-tests.tests.run
-    nix-expr-tests.tests.run
+          nix-store-tests.tests.run
-    nix-fetchers-tests.tests.run
+          nix-expr-tests.tests.run
-    nix-flake-tests.tests.run
+          nix-fetchers-tests.tests.run
+          nix-flake-tests.tests.run
 
-    # Make sure the functional tests have passed
+          # Make sure the functional tests have passed
-    nix-functional-tests
+          nix-functional-tests
 
-    # dev bundle is ok
+          # dev bundle is ok
-    # (checkInputs must be empty paths??)
+          # (checkInputs must be empty paths??)
-    (runCommand "check-pkg-config" { checked = dev.tests.pkg-config; } "mkdir $out")
+          (runCommand "check-pkg-config" { checked = dev.tests.pkg-config; } "mkdir $out")
-  ] ++ lib.optionals (!stdenv.hostPlatform.isStatic && stdenv.buildPlatform.canExecute stdenv.hostPlatform) [
+        ]
-    # Perl currently fails in static build
+        ++ lib.optionals
-    # TODO: Split out tests into a separate derivation?
+          (!stdenv.hostPlatform.isStatic && stdenv.buildPlatform.canExecute stdenv.hostPlatform)
-    nix-perl-bindings
+          [
-  ];
+            # Perl currently fails in static build
-  passthru = prevAttrs.passthru // {
+            # TODO: Split out tests into a separate derivation?
-    inherit (nix-cli) version;
+            nix-perl-bindings
+          ];
+      passthru = prevAttrs.passthru // {
+        inherit (nix-cli) version;
 
-    /**
+        /**
-      These are the libraries that are part of the Nix project. They are used
+          These are the libraries that are part of the Nix project. They are used
-      by the Nix CLI and other tools.
+          by the Nix CLI and other tools.
 
-      If you need to use these libraries in your project, we recommend to use
+          If you need to use these libraries in your project, we recommend to use
-      the `-c` C API libraries exclusively, if possible.
+          the `-c` C API libraries exclusively, if possible.
 
-      We also recommend that you build the complete package to ensure that the unit tests pass.
+          We also recommend that you build the complete package to ensure that the unit tests pass.
-      You could do this in CI, or by passing it in an unused environment variable. e.g in a `mkDerivation` call:
+          You could do this in CI, or by passing it in an unused environment variable. e.g in a `mkDerivation` call:
 
-      ```nix
+          ```nix
-        buildInputs = [ nix.libs.nix-util-c nix.libs.nix-store-c ];
+            buildInputs = [ nix.libs.nix-util-c nix.libs.nix-store-c ];
-        # Make sure the nix libs we use are ok
+            # Make sure the nix libs we use are ok
-        unusedInputsForTests = [ nix ];
+            unusedInputsForTests = [ nix ];
-        disallowedReferences = nix.all;
+            disallowedReferences = nix.all;
-      ```
+          ```
-     */
+        */
-    inherit libs;
+        inherit libs;
 
-    tests = prevAttrs.passthru.tests or {} // {
+        tests = prevAttrs.passthru.tests or { } // {
-      # TODO: create a proper fixpoint and:
+          # TODO: create a proper fixpoint and:
-      # pkg-config =
+          # pkg-config =
-      #   testers.hasPkgConfigModules {
+          #   testers.hasPkgConfigModules {
-      #     package = finalPackage;
+          #     package = finalPackage;
-      #   };
+          #   };
-    };
+        };
 
-    /**
+        /**
-      A derivation referencing the `dev` outputs of the Nix libraries.
+          A derivation referencing the `dev` outputs of the Nix libraries.
-     */
+        */
-    inherit dev;
+        inherit dev;
-    inherit devdoc;
+        inherit devdoc;
-    doc = nix-manual;
+        doc = nix-manual;
-    outputs = [ "out" "dev" "devdoc" "doc" ];
+        outputs = [
-    all = lib.attrValues (lib.genAttrs finalAttrs.passthru.outputs (outName: finalAttrs.finalPackage.${outName}));
+          "out"
-  };
+          "dev"
-  meta = prevAttrs.meta // {
+          "devdoc"
-    description = "The Nix package manager";
+          "doc"
-    pkgConfigModules = dev.meta.pkgConfigModules;
+        ];
-  };
+        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
+  shellInputs = removeAttrs (forAllSystems (
-    (forAllSystems (system: self.devShells.${system}.default.inputDerivation))
+    system: self.devShells.${system}.default.inputDerivation
-    [ "i686-linux" ];
+  )) [ "i686-linux" ];
 
-  buildStatic = forAllPackages (pkgName:
+  buildStatic = forAllPackages (
-    lib.genAttrs linux64BitSystems (system: nixpkgsFor.${system}.native.pkgsStatic.nixComponents.${pkgName}));
+    pkgName:
+    lib.genAttrs linux64BitSystems (
+      system: nixpkgsFor.${system}.native.pkgsStatic.nixComponents.${pkgName}
+    )
+  );
 
-  buildCross = forAllPackages (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:
+      if pkgName == "nix-functional-tests" then
-      lib.genAttrs [ "x86_64-linux" ] (system: nixpkgsFor.${system}.cross.${crossSystem}.nixComponents.${pkgName}))));
+        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
+  buildNoGc =
-    components = forAllSystems (system:
+    let
-      nixpkgsFor.${system}.native.nixComponents.overrideScope (self: super: {
+      components = forAllSystems (
-        nix-expr = super.nix-expr.override { enableGC = false; };
+        system:
-      })
+        nixpkgsFor.${system}.native.nixComponents.overrideScope (
-    );
+          self: super: {
-  in forAllPackages (pkgName: forAllSystems (system: components.${system}.${pkgName}));
+            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 (
-        nix-cmd = super.nix-cmd.override {
+        system:
-          enableMarkdown = false;
+        nixpkgsFor.${system}.native.nixComponents.overrideScope (
-          readlineFlavor = "readline";
+          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 (
-    tarballs = [ self.hydraJobs.binaryTarball.${system} ];
+    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,19 +183,20 @@ in
   external-api-docs = nixpkgsFor.x86_64-linux.native.nixComponents.nix-external-api-docs;
 
   # System tests.
-  tests = import ../tests/nixos {
+  tests =
-    inherit lib nixpkgs nixpkgsFor;
+    import ../tests/nixos {
-    inherit (self.inputs) nixpkgs-23-11;
+      inherit lib nixpkgs nixpkgsFor;
-  } // {
+      inherit (self.inputs) nixpkgs-23-11;
+    }
+    // {
 
-    # Make sure that nix-env still produces the exact same result
+      # Make sure that nix-env still produces the exact same result
-    # on a particular version of Nixpkgs.
+      # on a particular version of Nixpkgs.
-    evalNixpkgs =
+      evalNixpkgs =
-      let
+        let
-        inherit (nixpkgsFor.x86_64-linux.native) runCommand nix;
+          inherit (nixpkgsFor.x86_64-linux.native) runCommand nix;
-      in
+        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,36 +207,36 @@ 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;
-            lib = nixpkgsFor.${system}.native.lib;
+          nix = self.packages.${system}.nix-cli;
-            nix = self.packages.${system}.nix-cli;
+          pkgs = nixpkgsFor.${system}.native;
-            pkgs = nixpkgsFor.${system}.native;
+        }
-          }
       );
-  };
+    };
 
   metrics.nixpkgs = import "${nixpkgs-regression}/pkgs/top-level/metrics.nix" {
     pkgs = nixpkgsFor.x86_64-linux.native;
     nixpkgs = nixpkgs-regression;
   };
 
-  installTests = forAllSystems (system:
+  installTests = forAllSystems (
-    let pkgs = nixpkgsFor.${system}.native; in
+    system:
-    pkgs.runCommand "install-tests"
+    let
-      {
+      pkgs = nixpkgsFor.${system}.native;
-        againstSelf = testNixVersions pkgs pkgs.nix;
+    in
-        againstCurrentLatest =
+    pkgs.runCommand "install-tests" {
-          # FIXME: temporarily disable this on macOS because of #3605.
+      againstSelf = testNixVersions pkgs pkgs.nix;
-          if system == "x86_64-linux"
+      againstCurrentLatest =
-          then testNixVersions pkgs pkgs.nixVersions.latest
+        # FIXME: temporarily disable this on macOS because of #3605.
-          else null;
+        if system == "x86_64-linux" then testNixVersions pkgs pkgs.nixVersions.latest else null;
-        # Disabled because the latest stable version doesn't handle
+      # Disabled because the latest stable version doesn't handle
-        # `NIX_DAEMON_SOCKET_PATH` which is required for the tests to work
+      # `NIX_DAEMON_SOCKET_PATH` which is required for the tests to work
-        # againstLatestStable = testNixVersions pkgs pkgs.nixStable;
+      # againstLatestStable = testNixVersions pkgs pkgs.nixStable;
-      } "touch $out");
+    } "touch $out"
+  );
 
   installerTests = import ../tests/installer {
     binaryTarballs = self.hydraJobs.binaryTarball;

packaging/installer/default.nix

@@ -1,36 +1,42 @@
-{ lib
+{
-, runCommand
+  lib,
-, nix
+  runCommand,
-, tarballs
+  nix,
+  tarballs,
 }:
 
-runCommand "installer-script" {
+runCommand "installer-script"
-  buildInputs = [ nix ];
+  {
-} ''
+    buildInputs = [ nix ];
-  mkdir -p $out/nix-support
-
-  # Converts /nix/store/50p3qk8k...-nix-2.4pre20201102_550e11f/bin/nix to 50p3qk8k.../bin/nix.
-  tarballPath() {
-    # Remove the store prefix
-    local path=''${1#${builtins.storeDir}/}
-    # Get the path relative to the derivation root
-    local rest=''${path#*/}
-    # Get the derivation hash
-    local drvHash=''${path%%-*}
-    echo "$drvHash/$rest"
   }
+  ''
+    mkdir -p $out/nix-support
 
-  substitute ${./install.in} $out/install \
+    # Converts /nix/store/50p3qk8k...-nix-2.4pre20201102_550e11f/bin/nix to 50p3qk8k.../bin/nix.
-    ${lib.concatMapStrings
+    tarballPath() {
-      (tarball: let
+      # Remove the store prefix
-          inherit (tarball.stdenv.hostPlatform) system;
+      local path=''${1#${builtins.storeDir}/}
-        in '' \
+      # Get the path relative to the derivation root
-        --replace '@tarballHash_${system}@' $(nix --experimental-features nix-command hash-file --base16 --type sha256 ${tarball}/*.tar.xz) \
+      local rest=''${path#*/}
-        --replace '@tarballPath_${system}@' $(tarballPath ${tarball}/*.tar.xz) \
+      # Get the derivation hash
-        ''
+      local drvHash=''${path%%-*}
-      )
+      echo "$drvHash/$rest"
-      tarballs
+    }
-    } --replace '@nixVersion@' ${nix.version}
 
-  echo "file installer $out/install" >> $out/nix-support/hydra-build-products
+    substitute ${./install.in} $out/install \
-''
+      ${
+        lib.concatMapStrings (
+          tarball:
+          let
+            inherit (tarball.stdenv.hostPlatform) system;
+          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
+      } --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
+  # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -39,11 +40,10 @@ mkMesonDerivation (finalAttrs: {
     doxygen
   ];
 
-  preConfigure =
+  preConfigure = ''
-    ''
+    chmod u+w ./.version
-      chmod u+w ./.version
+    echo ${finalAttrs.version} > ./.version
-      echo ${finalAttrs.version} > ./.version
+  '';
-    '';
 
   postInstall = ''
     mkdir -p ''${!outputDoc}/nix-support

src/internal-api-docs/package.nix

@@ -1,11 +1,12 @@
-{ lib
+{
-, mkMesonDerivation
+  lib,
+  mkMesonDerivation,
 
-, doxygen
+  doxygen,
 
-# Configuration Options
+  # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -17,27 +18,28 @@ mkMesonDerivation (finalAttrs: {
   inherit version;
 
   workDir = ./.;
-  fileset = let
+  fileset =
-    cpp = fileset.fileFilter (file: file.hasExt "cc" || file.hasExt "hh");
+    let
-  in fileset.unions [
+      cpp = fileset.fileFilter (file: file.hasExt "cc" || file.hasExt "hh");
-    ./.version
+    in
-    ../../.version
+    fileset.unions [
-    ./meson.build
+      ./.version
-    ./doxygen.cfg.in
+      ../../.version
-    # Source is not compiled, but still must be available for Doxygen
+      ./meson.build
-    # to gather comments.
+      ./doxygen.cfg.in
-    (cpp ../.)
+      # Source is not compiled, but still must be available for Doxygen
-  ];
+      # to gather comments.
+      (cpp ../.)
+    ];
 
   nativeBuildInputs = [
     doxygen
   ];
 
-  preConfigure =
+  preConfigure = ''
-    ''
+    chmod u+w ./.version
-      chmod u+w ./.version
+    echo ${finalAttrs.version} > ./.version
-      echo ${finalAttrs.version} > ./.version
+  '';
-    '';
 
   postInstall = ''
     mkdir -p ''${!outputDoc}/nix-support

src/libcmd/package.nix

@@ -1,32 +1,33 @@
-{ 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
+  # Configuration Options
 
-, version
+  version,
 
-# Whether to enable Markdown rendering in the Nix binary.
+  # 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.
+  # Which interactive line editor library to use for Nix's repl.
-#
+  #
-# Currently supported choices are:
+  # Currently supported choices are:
-#
+  #
-# - editline (default)
+  # - editline (default)
-# - readline
+  # - 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
+  # 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
+  # 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
+  # Configuration Options
 
-, version
+  version,
-, resolvePath
+  resolvePath,
 }:
 
 let
@@ -58,16 +59,22 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = runCommand "${finalAttrs.pname}-run" {
+      run =
-        meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
+        runCommand "${finalAttrs.pname}-run"
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+          {
-        export HOME="$PWD/home-dir"
+            meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-        mkdir -p "$HOME"
+          }
-      '' + ''
+          (
-        export _NIX_TEST_UNIT_DATA=${resolvePath ./data}
+            lib.optionalString stdenv.hostPlatform.isWindows ''
-        ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
+              export HOME="$PWD/home-dir"
-        touch $out
+              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,77 +20,77 @@ 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
-        let
 
-          parentNode = allNodes.${getInputByPath lockFile.root node.parent};
+      parentNode = allNodes.${getInputByPath lockFile.root node.parent};
 
-          sourceInfo =
+      sourceInfo =
-            if overrides ? ${key}
+        if overrides ? ${key} then
-            then
+          overrides.${key}.sourceInfo
-              overrides.${key}.sourceInfo
+        else if node.locked.type == "path" && builtins.substring 0 1 node.locked.path != "/" then
-            else if node.locked.type == "path" && builtins.substring 0 1 node.locked.path != "/"
+          parentNode.sourceInfo
-            then
+          // {
-              parentNode.sourceInfo // {
+            outPath = parentNode.outPath + ("/" + node.locked.path);
-                outPath = parentNode.outPath + ("/" + node.locked.path);
+          }
-              }
+        else
-            else
+          # FIXME: remove obsolete node.info.
-              # FIXME: remove obsolete node.info.
+          # Note: lock file entries are always final.
-              # Note: lock file entries are always final.
+          fetchTreeFinal (node.info or { } // removeAttrs node.locked [ "dir" ]);
-              fetchTreeFinal (node.info or {} // removeAttrs node.locked ["dir"]);
 
-          subdir = overrides.${key}.dir or node.locked.dir or "";
+      subdir = overrides.${key}.dir or node.locked.dir or "";
 
-          outPath = sourceInfo + ((if subdir == "" then "" else "/") + subdir);
+      outPath = sourceInfo + ((if subdir == "" then "" else "/") + subdir);
 
-          flake = import (outPath + "/flake.nix");
+      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; });
+      outputs = flake.outputs (inputs // { self = result; });
 
-          result =
+      result =
-            outputs
+        outputs
-            # We add the sourceInfo attribute for its metadata, as they are
+        # We add the sourceInfo attribute for its metadata, as they are
-            # relevant metadata for the flake. However, the outPath of the
+        # relevant metadata for the flake. However, the outPath of the
-            # sourceInfo does not necessarily match the outPath of the flake,
+        # sourceInfo does not necessarily match the outPath of the flake,
-            # as the flake may be in a subdirectory of a source.
+        # as the flake may be in a subdirectory of a source.
-            # This is shadowed in the next //
+        # This is shadowed in the next //
-            // sourceInfo
+        // sourceInfo
-            // {
+        // {
-              # This shadows the sourceInfo.outPath
+          # This shadows the sourceInfo.outPath
-              inherit outPath;
+          inherit outPath;
 
-              inherit inputs; inherit outputs; inherit sourceInfo; _type = "flake";
+          inherit inputs;
-            };
+          inherit outputs;
+          inherit sourceInfo;
+          _type = "flake";
+        };
 
-        in
+    in
-          if node.flake or true then
+    if node.flake or true then
-            assert builtins.isFunction flake.outputs;
+      assert builtins.isFunction flake.outputs;
-            result
+      result
-          else
+    else
-            sourceInfo
+      sourceInfo
-      )
+  ) lockFile.nodes;
-      lockFile.nodes;
 
-in allNodes.${lockFile.root}
+in
+allNodes.${lockFile.root}

src/libexpr/fetchurl.nix

@@ -1,40 +1,72 @@
-{ system ? "" # obsolete
+{
-, url
+  system ? "", # obsolete
-, hash ? "" # an SRI hash
+  url,
+  hash ? "", # an SRI hash
 
-# Legacy hash specification
+  # Legacy hash specification
-, md5 ? "", sha1 ? "", sha256 ? "", sha512 ? ""
+  md5 ? "",
-, outputHash ?
+  sha1 ? "",
-    if hash != "" then hash else if sha512 != "" then sha512 else if sha1 != "" then sha1 else if md5 != "" then md5 else sha256
+  sha256 ? "",
-, outputHashAlgo ?
+  sha512 ? "",
-    if hash != "" then "" else if sha512 != "" then "sha512" else if sha1 != "" then "sha1" else if md5 != "" then "md5" else "sha256"
+  outputHash ?
+    if hash != "" then
+      hash
+    else if sha512 != "" then
+      sha512
+    else if sha1 != "" then
+      sha1
+    else if md5 != "" then
+      md5
+    else
+      sha256,
+  outputHashAlgo ?
+    if hash != "" then
+      ""
+    else if sha512 != "" then
+      "sha512"
+    else if sha1 != "" then
+      "sha1"
+    else if md5 != "" then
+      "md5"
+    else
+      "sha256",
 
-, executable ? false
+  executable ? false,
-, unpack ? false
+  unpack ? false,
-, name ? baseNameOf (toString url)
+  name ? baseNameOf (toString url),
-, impure ? false
+  impure ? false,
 }:
 
-derivation ({
+derivation (
-  builder = "builtin:fetchurl";
+  {
+    builder = "builtin:fetchurl";
 
-  # New-style output content requirements.
+    # New-style output content requirements.
-  outputHashMode = if unpack || executable then "recursive" else "flat";
+    outputHashMode = if unpack || executable then "recursive" else "flat";
 
-  inherit name url executable unpack;
+    inherit
+      name
+      url
+      executable
+      unpack
+      ;
 
-  system = "builtin";
+    system = "builtin";
 
-  # No need to double the amount of network traffic
+    # No need to double the amount of network traffic
-  preferLocalBuild = true;
+    preferLocalBuild = true;
 
-  # This attribute does nothing; it's here to avoid changing evaluation results.
+    # This attribute does nothing; it's here to avoid changing evaluation results.
-  impureEnvVars = [
+    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.
+    # To make "nix-prefetch-url" work.
-  urls = [ url ];
+    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,21 +1,27 @@
-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;
+    inherit drvPath name;
-      type = "derivation";
+    type = "derivation";
-    };
+  };
 
-  outputToAttrListElement = outputName:
+  outputToAttrListElement = outputName: {
-    { name = outputName;
+    name = outputName;
-      value = commonAttrs // {
+    value = commonAttrs // {
-        outPath = builtins.getAttr outputName attrs;
+      outPath = builtins.getAttr outputName attrs;
-        inherit outputName;
+      inherit outputName;
-      };
     };
+  };
 
   outputsList = map outputToAttrListElement outputs;
 
-in (builtins.head outputsList).value
+in
+(builtins.head outputsList).value

src/libexpr/package.nix

@@ -1,33 +1,34 @@
-{ 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
+  # Configuration Options
 
-, version
+  version,
 
-# Whether to use garbage collection for the Nix language evaluator.
+  # Whether to use garbage collection for the Nix language evaluator.
-#
+  #
-# If it is disabled, we just leak memory, but this is not as bad as it
+  # If it is disabled, we just leak memory, but this is not as bad as it
-# sounds so long as evaluation just takes places within short-lived
+  # sounds so long as evaluation just takes places within short-lived
-# processes. (When the process exits, the memory is reclaimed; it is
+  # processes. (When the process exits, the memory is reclaimed; it is
-# only leaked *within* the process.)
+  # only leaked *within* the process.)
-#
+  #
-# Temporarily disabled on Windows because the `GC_throw_bad_alloc`
+  # Temporarily disabled on Windows because the `GC_throw_bad_alloc`
-# symbol is missing during linking.
+  # 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,27 +26,34 @@
   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 // {
+    value = commonAttrs // {
-        outPath = builtins.getAttr outputName strict;
+      outPath = builtins.getAttr outputName strict;
-        drvPath = strict.drvPath;
+      drvPath = strict.drvPath;
-        type = "derivation";
+      type = "derivation";
-        inherit outputName;
+      inherit outputName;
-      };
     };
+  };
 
   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
+  # Configuration Options
 
-, version
+  version,
-, resolvePath
+  resolvePath,
 }:
 
 let
@@ -56,16 +57,22 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = runCommand "${finalAttrs.pname}-run" {
+      run =
-        meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
+        runCommand "${finalAttrs.pname}-run"
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+          {
-        export HOME="$PWD/home-dir"
+            meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-        mkdir -p "$HOME"
+          }
-      '' + ''
+          (
-        export _NIX_TEST_UNIT_DATA=${resolvePath ./data}
+            lib.optionalString stdenv.hostPlatform.isWindows ''
-        ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
+              export HOME="$PWD/home-dir"
-        touch $out
+              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
+  # 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
+  # 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
+  # Configuration Options
 
-, version
+  version,
-, resolvePath
+  resolvePath,
 }:
 
 let
@@ -58,17 +59,23 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = runCommand "${finalAttrs.pname}-run" {
+      run =
-        meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
+        runCommand "${finalAttrs.pname}-run"
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+          {
-        export HOME="$PWD/home-dir"
+            meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-        mkdir -p "$HOME"
+          }
-      '' + ''
+          (
-        export _NIX_TEST_UNIT_DATA=${resolvePath ./data}
+            lib.optionalString stdenv.hostPlatform.isWindows ''
-        export NIX_CONFIG="extra-experimental-features = flakes"
+              export HOME="$PWD/home-dir"
-        ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
+              mkdir -p "$HOME"
-        touch $out
+            ''
-      '');
+            + ''
+              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
+  # 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
+  # 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
+  # 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
+  # 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
+  # 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
+  # Configuration Options
 
-, version
+  version,
-, filesetToSource
+  filesetToSource,
 }:
 
 let
@@ -64,26 +65,33 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = let
+      run =
-        # Some data is shared with the functional tests: they create it,
+        let
-        # we consume it.
+          # Some data is shared with the functional tests: they create it,
-        data = filesetToSource {
+          # we consume it.
-          root = ../..;
+          data = filesetToSource {
-          fileset = lib.fileset.unions [
+            root = ../..;
-            ./data
+            fileset = lib.fileset.unions [
-            ../../tests/functional/derivation
+              ./data
-          ];
+              ../../tests/functional/derivation
-        };
+            ];
-      in runCommand "${finalAttrs.pname}-run" {
+          };
-        meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
+        in
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+        runCommand "${finalAttrs.pname}-run"
-        export HOME="$PWD/home-dir"
+          {
-        mkdir -p "$HOME"
+            meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-      '' + ''
+          }
-        export _NIX_TEST_UNIT_DATA=${data + "/src/libstore-tests/data"}
+          (
-        ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
+            lib.optionalString stdenv.hostPlatform.isWindows ''
-        touch $out
+              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
+  # 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
+      boost
-    sqlite
+      curl
-  ] ++ lib.optional stdenv.hostPlatform.isLinux libseccomp
+      sqlite
+    ]
+    ++ 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,12 +77,14 @@ mkMesonLibrary (finalAttrs: {
       echo ${version} > ../../.version
     '';
 
-  mesonFlags = [
+  mesonFlags =
-    (lib.mesonEnable "seccomp-sandboxing" stdenv.hostPlatform.isLinux)
+    [
-    (lib.mesonBool "embedded-sandbox-shell" embeddedSandboxShell)
+      (lib.mesonEnable "seccomp-sandboxing" stdenv.hostPlatform.isLinux)
-  ] ++ lib.optionals stdenv.hostPlatform.isLinux [
+      (lib.mesonBool "embedded-sandbox-shell" embeddedSandboxShell)
-    (lib.mesonOption "sandbox-shell" "${busybox-sandbox-shell}/bin/busybox")
+    ]
-  ];
+    ++ lib.optionals stdenv.hostPlatform.isLinux [
+      (lib.mesonOption "sandbox-shell" "${busybox-sandbox-shell}/bin/busybox")
+    ];
 
   env = {
     # Needed for Meson to find Boost.

src/libutil-c/package.nix

@@ -1,11 +1,12 @@
-{ lib
+{
-, mkMesonLibrary
+  lib,
+  mkMesonLibrary,
 
-, nix-util
+  nix-util,
 
-# Configuration Options
+  # 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
+  # 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
+  # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -57,16 +58,22 @@ mkMesonExecutable (finalAttrs: {
 
   passthru = {
     tests = {
-      run = runCommand "${finalAttrs.pname}-run" {
+      run =
-        meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
+        runCommand "${finalAttrs.pname}-run"
-      } (lib.optionalString stdenv.hostPlatform.isWindows ''
+          {
-        export HOME="$PWD/home-dir"
+            meta.broken = !stdenv.hostPlatform.emulatorAvailable buildPackages;
-        mkdir -p "$HOME"
+          }
-      '' + ''
+          (
-        export _NIX_TEST_UNIT_DATA=${./data}
+            lib.optionalString stdenv.hostPlatform.isWindows ''
-        ${stdenv.hostPlatform.emulator buildPackages} ${lib.getExe finalAttrs.finalPackage}
+              export HOME="$PWD/home-dir"
-        touch $out
+              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
+  # 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.priority or 5)
+      (d.meta.active or "true")
-        (builtins.length d.outputs)
+      (d.meta.priority or 5)
-      ] ++ map (output: builtins.getAttr output d) d.outputs)
+      (builtins.length 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
+  # Configuration Options
 
-, version
+  version,
 }:
 
 let
@@ -20,64 +21,67 @@ mkMesonExecutable (finalAttrs: {
   inherit version;
 
   workDir = ./.;
-  fileset = fileset.unions ([
+  fileset = fileset.unions (
-    ../../nix-meson-build-support
-    ./nix-meson-build-support
-    ../../.version
-    ./.version
-    ./meson.build
-    ./meson.options
-
-    # Symbolic links to other dirs
-    ## exes
-    ./build-remote
-    ./doc
-    ./nix-build
-    ./nix-channel
-    ./nix-collect-garbage
-    ./nix-copy-closure
-    ./nix-env
-    ./nix-instantiate
-    ./nix-store
-    ## dirs
-    ./scripts
-    ../../scripts
-    ./misc
-    ../../misc
-
-    # Doc nix files for --help
-    ../../doc/manual/generate-manpage.nix
-    ../../doc/manual/utils.nix
-    ../../doc/manual/generate-settings.nix
-    ../../doc/manual/generate-store-info.nix
-
-    # Other files to be included as string literals
-    ../nix-channel/unpack-channel.nix
-    ../nix-env/buildenv.nix
-    ./get-env.sh
-    ./help-stores.md
-    ../../doc/manual/source/store/types/index.md.in
-    ./profiles.md
-    ../../doc/manual/source/command-ref/files/profiles.md
-
-    # Files
-  ] ++ lib.concatMap
-    (dir: [
-      (fileset.fileFilter (file: file.hasExt "cc") dir)
-      (fileset.fileFilter (file: file.hasExt "hh") dir)
-      (fileset.fileFilter (file: file.hasExt "md") dir)
-    ])
     [
-      ./.
+      ../../nix-meson-build-support
-      ../build-remote
+      ./nix-meson-build-support
-      ../nix-build
+      ../../.version
-      ../nix-channel
+      ./.version
-      ../nix-collect-garbage
+      ./meson.build
-      ../nix-copy-closure
+      ./meson.options
-      ../nix-env
+
-      ../nix-instantiate
+      # Symbolic links to other dirs
-      ../nix-store
+      ## exes
+      ./build-remote
+      ./doc
+      ./nix-build
+      ./nix-channel
+      ./nix-collect-garbage
+      ./nix-copy-closure
+      ./nix-env
+      ./nix-instantiate
+      ./nix-store
+      ## dirs
+      ./scripts
+      ../../scripts
+      ./misc
+      ../../misc
+
+      # Doc nix files for --help
+      ../../doc/manual/generate-manpage.nix
+      ../../doc/manual/utils.nix
+      ../../doc/manual/generate-settings.nix
+      ../../doc/manual/generate-store-info.nix
+
+      # Other files to be included as string literals
+      ../nix-channel/unpack-channel.nix
+      ../nix-env/buildenv.nix
+      ./get-env.sh
+      ./help-stores.md
+      ../../doc/manual/source/store/types/index.md.in
+      ./profiles.md
+      ../../doc/manual/source/command-ref/files/profiles.md
+
+      # Files
     ]
+    ++
+      lib.concatMap
+        (dir: [
+          (fileset.fileFilter (file: file.hasExt "cc") dir)
+          (fileset.fileFilter (file: file.hasExt "hh") dir)
+          (fileset.fileFilter (file: file.hasExt "md") dir)
+        ])
+        [
+          ./.
+          ../build-remote
+          ../nix-build
+          ../nix-channel
+          ../nix-collect-garbage
+          ../nix-copy-closure
+          ../nix-env
+          ../nix-instantiate
+          ../nix-store
+        ]
   );
 
   buildInputs = [

src/perl/package.nix

@@ -1,76 +1,82 @@
-{ 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 (
-  pname = "nix-perl";
+  mkMesonDerivation (finalAttrs: {
-  inherit version;
+    pname = "nix-perl";
+    inherit version;
 
-  workDir = ./.;
+    workDir = ./.;
-  fileset = fileset.unions ([
+    fileset = fileset.unions (
-    ./.version
+      [
-    ../../.version
+        ./.version
-    ./MANIFEST
+        ../../.version
-    ./lib
+        ./MANIFEST
-    ./meson.build
+        ./lib
-    ./meson.options
+        ./meson.build
-  ] ++ lib.optionals finalAttrs.doCheck [
+        ./meson.options
-    ./.yath.rc.in
+      ]
-    ./t
+      ++ lib.optionals finalAttrs.doCheck [
-  ]);
+        ./.yath.rc.in
+        ./t
+      ]
+    );
 
-  nativeBuildInputs = [
+    nativeBuildInputs = [
-    pkg-config
+      pkg-config
-    perl
+      perl
-    curl
+      curl
-  ];
+    ];
 
-  buildInputs = [
+    buildInputs = [
-    nix-store
+      nix-store
-  ] ++ finalAttrs.passthru.externalBuildInputs;
+    ] ++ finalAttrs.passthru.externalBuildInputs;
 
-  # Hack for sake of the dev shell
+    # Hack for sake of the dev shell
-  passthru.externalBuildInputs = [
+    passthru.externalBuildInputs = [
-    bzip2
+      bzip2
-    libsodium
+      libsodium
-  ];
+    ];
 
-  # `perlPackages.Test2Harness` is marked broken for Darwin
+    # `perlPackages.Test2Harness` is marked broken for Darwin
-  doCheck = !stdenv.isDarwin;
+    doCheck = !stdenv.isDarwin;
 
-  nativeCheckInputs = [
+    nativeCheckInputs = [
-    perlPackages.Test2Harness
+      perlPackages.Test2Harness
-  ];
+    ];
 
-  preConfigure =
+    preConfigure =
-    # "Inline" .version so its not a symlink, and includes the suffix
+      # "Inline" .version so its not a symlink, and includes the suffix
-    ''
+      ''
-      chmod u+w .version
+        chmod u+w .version
-      echo ${finalAttrs.version} > .version
+        echo ${finalAttrs.version} > .version
-    '';
+      '';
 
-  mesonFlags = [
+    mesonFlags = [
-    (lib.mesonOption "dbi_path" "${perlPackages.DBI}/${perl.libPrefix}")
+      (lib.mesonOption "dbi_path" "${perlPackages.DBI}/${perl.libPrefix}")
-    (lib.mesonOption "dbd_sqlite_path" "${perlPackages.DBDSQLite}/${perl.libPrefix}")
+      (lib.mesonOption "dbd_sqlite_path" "${perlPackages.DBDSQLite}/${perl.libPrefix}")
-    (lib.mesonEnable "tests" finalAttrs.doCheck)
+      (lib.mesonEnable "tests" finalAttrs.doCheck)
-  ];
+    ];
 
-  mesonCheckFlags = [
+    mesonCheckFlags = [
-    "--print-errorlogs"
+      "--print-errorlogs"
-  ];
+    ];
 
-  strictDeps = false;
+    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,24 +4,39 @@ with import ./config.nix;
 
 let
 
-  mkDerivation = args:
+  mkDerivation =
-    derivation ({
+    args:
-      inherit system;
+    derivation (
-      builder = busybox;
+      {
-      args = ["sh" "-e" args.builder or (builtins.toFile "builder-${args.name}.sh" ''
+        inherit system;
-        if [ -e "$NIX_ATTRS_SH_FILE" ]; then source $NIX_ATTRS_SH_FILE; fi;
+        builder = busybox;
-        eval "$buildCommand"
+        args = [
-      '')];
+          "sh"
-      outputHashMode = "recursive";
+          "-e"
-      outputHashAlgo = "sha256";
+          args.builder or (builtins.toFile "builder-${args.name}.sh" ''
-    } // removeAttrs args ["builder" "meta" "passthru"])
+            if [ -e "$NIX_ATTRS_SH_FILE" ]; then source $NIX_ATTRS_SH_FILE; fi;
-    // { meta = args.meta or {}; passthru = args.passthru or {}; };
+            eval "$buildCommand"
+          '')
+        ];
+        outputHashMode = "recursive";
+        outputHashAlgo = "sha256";
+      }
+      // removeAttrs args [
+        "builder"
+        "meta"
+        "passthru"
+      ]
+    )
+    // {
+      meta = args.meta or { };
+      passthru = args.passthru or { };
+    };
 
   input1 = mkDerivation {
     shell = busybox;
     name = "build-remote-input-1";
     buildCommand = "echo hi-input1; echo FOO > $out";
-    requiredSystemFeatures = ["foo"];
+    requiredSystemFeatures = [ "foo" ];
     outputHash = "sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc=";
   };
 
@@ -29,7 +44,7 @@ let
     shell = busybox;
     name = "build-remote-input-2";
     buildCommand = "echo hi; echo BAR > $out";
-    requiredSystemFeatures = ["bar"];
+    requiredSystemFeatures = [ "bar" ];
     outputHash = "sha256-XArauVH91AVwP9hBBQNlkX9ccuPpSYx9o0zeIHb6e+Q=";
   };
 
@@ -41,21 +56,20 @@ let
       read x < ${input2}
       echo $x BAZ > $out
     '';
-    requiredSystemFeatures = ["baz"];
+    requiredSystemFeatures = [ "baz" ];
     outputHash = "sha256-daKAcPp/+BYMQsVi/YYMlCKoNAxCNDsaivwSHgQqD2s=";
   };
 
 in
 
-  mkDerivation {
+mkDerivation {
-    shell = busybox;
+  shell = busybox;
-    name = "build-remote";
+  name = "build-remote";
-    passthru = { inherit input1 input2 input3; };
+  passthru = { inherit input1 input2 input3; };
-    buildCommand =
+  buildCommand = ''
-      ''
+    read x < ${input1}
-        read x < ${input1}
+    read y < ${input3}
-        read y < ${input3}
+    echo "$x $y" > $out
-        echo "$x $y" > $out
+  '';
-      '';
+  outputHash = "sha256-5SxbkUw6xe2l9TE1uwCvTtTDysD1vhRor38OtDF0LqQ=";
-    outputHash = "sha256-5SxbkUw6xe2l9TE1uwCvTtTDysD1vhRor38OtDF0LqQ=";
+}
-  }

tests/functional/build-hook.nix

@@ -1,39 +1,61 @@
-{ busybox, contentAddressed ? false }:
+{
+  busybox,
+  contentAddressed ? false,
+}:
 
 with import ./config.nix;
 
 let
 
-  caArgs = if contentAddressed then {
+  caArgs =
-      outputHashMode = "recursive";
+    if contentAddressed then
-      outputHashAlgo = "sha256";
+      {
-      __contentAddressed = true;
+        outputHashMode = "recursive";
-    } else {};
+        outputHashAlgo = "sha256";
+        __contentAddressed = true;
+      }
+    else
+      { };
 
-  mkDerivation = args:
+  mkDerivation =
-    derivation ({
+    args:
-      inherit system;
+    derivation (
-      builder = busybox;
+      {
-      args = ["sh" "-e" args.builder or (builtins.toFile "builder-${args.name}.sh" ''
+        inherit system;
-        if [ -e "$NIX_ATTRS_SH_FILE" ]; then source $NIX_ATTRS_SH_FILE; fi;
+        builder = busybox;
-        eval "$buildCommand"
+        args = [
-      '')];
+          "sh"
-    } // removeAttrs args ["builder" "meta" "passthru"]
+          "-e"
-    // caArgs)
+          args.builder or (builtins.toFile "builder-${args.name}.sh" ''
-    // { meta = args.meta or {}; passthru = args.passthru or {}; };
+            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 { };
+    };
 
   input1 = mkDerivation {
     shell = busybox;
     name = "build-remote-input-1";
     buildCommand = "echo hi-input1; echo FOO > $out";
-    requiredSystemFeatures = ["foo"];
+    requiredSystemFeatures = [ "foo" ];
   };
 
   input2 = mkDerivation {
     shell = busybox;
     name = "build-remote-input-2";
     buildCommand = "echo hi; echo BAR > $out";
-    requiredSystemFeatures = ["bar"];
+    requiredSystemFeatures = [ "bar" ];
   };
 
   input3 = mkDerivation {
@@ -44,19 +66,18 @@ let
       read x < ${input2}
       echo $x BAZ > $out
     '';
-    requiredSystemFeatures = ["baz"];
+    requiredSystemFeatures = [ "baz" ];
   };
 
 in
 
-  mkDerivation {
+mkDerivation {
-    shell = busybox;
+  shell = busybox;
-    name = "build-remote";
+  name = "build-remote";
-    passthru = { inherit input1 input2 input3; };
+  passthru = { inherit input1 input2 input3; };
-    buildCommand =
+  buildCommand = ''
-      ''
+    read x < ${input1}
-        read x < ${input1}
+    read y < ${input3}
-        read y < ${input3}
+    echo "$x $y" > $out
-        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
-    __contentAddressed = true;
+  mkCADerivation =
-    outputHashMode = "recursive";
+    args:
-    outputHashAlgo = "sha256";
+    mkDerivation (
-} // args);
+      {
+        __contentAddressed = true;
+        outputHashMode = "recursive";
+        outputHashAlgo = "sha256";
+      }
+      // 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/flake.nix

@@ -1,3 +1,3 @@
 {
-  outputs = { self }: import ./content-addressed.nix {};
+  outputs = { self }: import ./content-addressed.nix { };
 }

tests/functional/ca/nondeterministic.nix

@@ -1,10 +1,16 @@
 with import ./config.nix;
 
-let mkCADerivation = args: mkDerivation ({
+let
-    __contentAddressed = true;
+  mkCADerivation =
-    outputHashMode = "recursive";
+    args:
-    outputHashAlgo = "sha256";
+    mkDerivation (
-} // args);
+      {
+        __contentAddressed = true;
+        outputHashMode = "recursive";
+        outputHashAlgo = "sha256";
+      }
+      // args
+    );
 in
 
 rec {
@@ -15,13 +21,15 @@ rec {
       echo $(date) > $out/current-time
     '';
   };
-  dep = seed: mkCADerivation {
+  dep =
-    name = "dep";
+    seed:
-    inherit seed;
+    mkCADerivation {
-    buildCommand = ''
+      name = "dep";
-      echo ${currentTime} > $out
+      inherit seed;
-    '';
+      buildCommand = ''
-  };
+        echo ${currentTime} > $out
+      '';
+    };
   dep1 = dep 1;
   dep2 = dep 2;
   toplevel = mkCADerivation {
@@ -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

@@ -2,11 +2,16 @@ with import ./config.nix;
 
 rec {
 
-  dep = import ./dependencies.nix {};
+  dep = import ./dependencies.nix { };
 
-  makeTest = nr: args: mkDerivation ({
+  makeTest =
-    name = "check-refs-" + toString nr;
+    nr: args:
-  } // args);
+    mkDerivation (
+      {
+        name = "check-refs-" + toString nr;
+      }
+      // args
+    );
 
   src = builtins.toFile "aux-ref" "bla bla";
 
@@ -22,31 +27,31 @@ rec {
 
   test3 = makeTest 3 {
     builder = builtins.toFile "builder.sh" "mkdir $out; ln -s $dep $out/link";
-    allowedReferences = [];
+    allowedReferences = [ ];
     inherit dep;
   };
 
   test4 = makeTest 4 {
     builder = builtins.toFile "builder.sh" "mkdir $out; ln -s $dep $out/link";
-    allowedReferences = [dep];
+    allowedReferences = [ dep ];
     inherit dep;
   };
 
   test5 = makeTest 5 {
     builder = builtins.toFile "builder.sh" "mkdir $out";
-    allowedReferences = [];
+    allowedReferences = [ ];
     inherit dep;
   };
 
   test6 = makeTest 6 {
     builder = builtins.toFile "builder.sh" "mkdir $out; ln -s $out $out/link";
-    allowedReferences = [];
+    allowedReferences = [ ];
     inherit dep;
   };
 
   test7 = makeTest 7 {
     builder = builtins.toFile "builder.sh" "mkdir $out; ln -s $out $out/link";
-    allowedReferences = ["out"];
+    allowedReferences = [ "out" ];
     inherit dep;
   };
 
@@ -58,19 +63,19 @@ rec {
   test9 = makeTest 9 {
     builder = builtins.toFile "builder.sh" "mkdir $out; ln -s $dep $out/link";
     inherit dep;
-    disallowedReferences = [dep];
+    disallowedReferences = [ dep ];
   };
 
   test10 = makeTest 10 {
     builder = builtins.toFile "builder.sh" "mkdir $out; echo $test5; ln -s $dep $out/link";
     inherit dep test5;
-    disallowedReferences = [test5];
+    disallowedReferences = [ test5 ];
   };
 
   test11 = makeTest 11 {
     __structuredAttrs = true;
     unsafeDiscardReferences.out = true;
-    outputChecks.out.allowedReferences = [];
+    outputChecks.out.allowedReferences = [ ];
     buildCommand = ''echo ${dep} > "''${outputs[out]}"'';
   };
 

tests/functional/check-reqs.nix

@@ -22,36 +22,48 @@ rec {
     '';
   };
 
-  makeTest = nr: allowreqs: mkDerivation {
+  makeTest =
-    name = "check-reqs-" + toString nr;
+    nr: allowreqs:
-    inherit deps;
+    mkDerivation {
-    builder = builtins.toFile "builder.sh" ''
+      name = "check-reqs-" + toString nr;
-      mkdir $out
+      inherit deps;
-      ln -s $deps $out/depdir1
+      builder = builtins.toFile "builder.sh" ''
-    '';
+        mkdir $out
-    allowedRequisites = allowreqs;
+        ln -s $deps $out/depdir1
-  };
+      '';
+      allowedRequisites = allowreqs;
+    };
 
   # 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 [];
+  test5 = makeTest 5 [ ];
 
   test6 = mkDerivation {
     name = "check-reqs";
     inherit deps;
     builder = builtins.toFile "builder.sh" "mkdir $out; ln -s $deps $out/depdir1";
-    disallowedRequisites = [dep1];
+    disallowedRequisites = [ dep1 ];
   };
 
   test7 = mkDerivation {
     name = "check-reqs";
     inherit deps;
     builder = builtins.toFile "builder.sh" "mkdir $out; ln -s $deps $out/depdir1";
-    disallowedRequisites = [test1];
+    disallowedRequisites = [ test1 ];
   };
 }

tests/functional/check.nix

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

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,42 +4,58 @@ 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"];
+  __impureHostDeps = [ "/usr/bin/ditto" ];
-  impureEnvVars = ["UNICORN"];
+  impureEnvVars = [ "UNICORN" ];
   __darwinAllowLocalNetworking = true;
-  outputs = [ "out" "bin" "dev" ];
+  outputs = [
+    "out"
+    "bin"
+    "dev"
+  ];
   __structuredAttrs = true;
   outputChecks = {
     out = {
-      allowedReferences = [foo];
+      allowedReferences = [ foo ];
-      allowedRequisites = [foo];
+      allowedRequisites = [ foo ];
     };
     bin = {
-      disallowedReferences = [bar];
+      disallowedReferences = [ bar ];
-      disallowedRequisites = [bar];
+      disallowedRequisites = [ bar ];
     };
     dev = {
       maxSize = 789;
       maxClosureSize = 5909;
     };
   };
-  requiredSystemFeatures = ["rainbow" "uid-range"];
+  requiredSystemFeatures = [
+    "rainbow"
+    "uid-range"
+  ];
   preferLocalBuild = true;
   allowSubstitutes = false;
 }

tests/functional/derivation/advanced-attributes.nix

@@ -4,30 +4,42 @@ 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"];
+  __impureHostDeps = [ "/usr/bin/ditto" ];
-  impureEnvVars = ["UNICORN"];
+  impureEnvVars = [ "UNICORN" ];
   __darwinAllowLocalNetworking = true;
-  allowedReferences = [foo];
+  allowedReferences = [ foo ];
-  allowedRequisites = [foo];
+  allowedRequisites = [ foo ];
-  disallowedReferences = [bar];
+  disallowedReferences = [ bar ];
-  disallowedRequisites = [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,28 +2,33 @@ with import ./config.nix;
 
 rec {
 
-  printRefs =
+  printRefs = ''
-    ''
+    echo $exportReferencesGraph
-      echo $exportReferencesGraph
+    while read path; do
-      while read path; do
+        read drv
-          read drv
+        read nrRefs
-          read nrRefs
+        echo "$path has $nrRefs references"
-          echo "$path has $nrRefs references"
+        echo "$path" >> $out
-          echo "$path" >> $out
+        for ((n = 0; n < $nrRefs; n++)); do read ref; echo "ref $ref"; test -e "$ref"; done
-          for ((n = 0; n < $nrRefs; n++)); do read ref; echo "ref $ref"; test -e "$ref"; done
+    done < refs
-      done < refs
+  '';
-    '';
 
   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:
-      inherit system;
+    derivation (
-      builder = busybox;
+      {
-      args = ["sh" "-e" args.builder or (builtins.toFile "builder-${args.name}.sh" ''
+        inherit system;
-        if [ -e "$NIX_ATTRS_SH_FILE" ]; then source $NIX_ATTRS_SH_FILE; fi;
+        builder = busybox;
-        eval "$buildCommand"
+        args = [
-      '')];
+          "sh"
-    } // removeAttrs args ["builder" "meta"])
+          "-e"
-    // { meta = args.meta or {}; };
+          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 { };
+    };
 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
-      type != "symlink"
+      filter =
-      && baseNameOf path != "foo"
+        path: type:
-      && !((import ./lang/lib.nix).hasSuffix ".bak" (baseNameOf path));
+        type != "symlink"
-    in builtins.filterSource filter ((builtins.getEnv "TEST_ROOT") + "/filterin");
+        && baseNameOf path != "foo"
+        && !((import ./lang/lib.nix).hasSuffix ".bak" (baseNameOf path));
+    in
+    builtins.filterSource filter ((builtins.getEnv "TEST_ROOT") + "/filterin");
 }

tests/functional/fixed.nix

@@ -2,15 +2,20 @@ with import ./config.nix;
 
 rec {
 
-  f2 = dummy: builder: mode: algo: hash: mkDerivation {
+  f2 =
-    name = "fixed";
+    dummy: builder: mode: algo: hash:
-    inherit builder;
+    mkDerivation {
-    outputHashMode = mode;
+      name = "fixed";
-    outputHashAlgo = algo;
+      inherit builder;
-    outputHash = hash;
+      outputHashMode = mode;
-    inherit dummy;
+      outputHashAlgo = algo;
-    impureEnvVars = ["IMPURE_VAR1" "IMPURE_VAR2"];
+      outputHash = hash;
-  };
+      inherit dummy;
+      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,38 +2,34 @@ with import ./config.nix;
 rec {
   x1 = mkDerivation {
     name = "x1";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
+      echo $name > $out
-        echo $name > $out
+    '';
-      '';
     outputHashMode = "recursive";
     outputHash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
   };
   x2 = mkDerivation {
     name = "x2";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
+      echo $name > $out
-        echo $name > $out
+    '';
-      '';
     outputHashMode = "recursive";
     outputHash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
   };
   x3 = mkDerivation {
     name = "x3";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
+      echo $name > $out
-        echo $name > $out
+    '';
-      '';
     outputHashMode = "recursive";
     outputHash = "sha256-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=";
   };
   x4 = mkDerivation {
     name = "x4";
     inherit x2 x3;
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
+      echo $x2 $x3
-        echo $x2 $x3
+      exit 1
-        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,
-# If we want the final derivation output to have references to its
+  seed,
-# dependencies. Some tests need/want this, other don't.
+  # If we want the final derivation output to have references to its
-, withFinalRefs ? false
+  # dependencies. Some tests need/want this, other don't.
+  withFinalRefs ? false,
 }:
 
 with import ./config.nix;
 
 let
   contentAddressedByDefault = builtins.getEnv "NIX_TESTS_CA_BY_DEFAULT" == "1";
-  caArgs = if contentAddressedByDefault then {
+  caArgs =
-    __contentAddressed = true;
+    if contentAddressedByDefault then
-    outputHashMode = "recursive";
+      {
-    outputHashAlgo = "sha256";
+        __contentAddressed = true;
-  } else {};
+        outputHashMode = "recursive";
+        outputHashAlgo = "sha256";
+      }
+    else
+      { };
 
-  mkDerivation = args:
+  mkDerivation =
-    derivation ({
+    args:
-      inherit system;
+    derivation (
-      builder = busybox;
+      {
-      args = ["sh" "-e" args.builder or (builtins.toFile "builder-${args.name}.sh" ''
+        inherit system;
-        if [ -e "$NIX_ATTRS_SH_FILE" ]; then source $NIX_ATTRS_SH_FILE; fi;
+        builder = busybox;
-        eval "$buildCommand"
+        args = [
-      '')];
+          "sh"
-    } // removeAttrs args ["builder" "meta" "passthru"]
+          "-e"
-    // caArgs)
+          args.builder or (builtins.toFile "builder-${args.name}.sh" ''
-    // { meta = args.meta or {}; passthru = args.passthru or {}; };
+            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 { };
+    };
 
   input1 = mkDerivation {
     shell = busybox;
@@ -51,14 +71,15 @@ let
 
 in
 
-  mkDerivation {
+mkDerivation {
-    shell = busybox;
+  shell = busybox;
-    name = "hermetic";
+  name = "hermetic";
-    passthru = { inherit input1 input2 input3; };
+  passthru = { inherit input1 input2 input3; };
-    buildCommand =
+  buildCommand = ''
-      ''
+    read x < ${input1}
-        read x < ${input1}
+    read y < ${input3}
-        read y < ${input3}
+    echo ${
-        echo ${if (builtins.trace withFinalRefs withFinalRefs) then "${input1} ${input3}" else ""} "$x $y" > $out
+      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";
-    name = "foo";
+  bla = import ./dependencies.nix { };
-    bla = import ./dependencies.nix {};
+  buildCommand = "
-    buildCommand = "
       echo \\\"hi\\\" > $out
     ";
-  }
+})
-)

tests/functional/import-from-derivation.nix

@@ -3,10 +3,9 @@ with import <config>;
 rec {
   bar = mkDerivation {
     name = "bar";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
+      echo 'builtins.add 123 456' > $out
-        echo 'builtins.add 123 456' > $out
+    '';
-      '';
   };
 
   value =
@@ -16,19 +15,17 @@ rec {
 
   result = mkDerivation {
     name = "foo";
-    builder = builtins.toFile "builder.sh"
+    builder = builtins.toFile "builder.sh" ''
-      ''
+      echo -n FOO${toString value} > $out
-        echo -n FOO${toString value} > $out
+    '';
-      '';
   };
 
   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
-        echo -n BLA$(cat $src) > $out
+    '';
-      '';
   };
 
   step1 = mkDerivation {

tests/functional/impure-derivations.nix

@@ -4,60 +4,58 @@ rec {
 
   impure = mkDerivation {
     name = "impure";
-    outputs = [ "out" "stuff" ];
+    outputs = [
-    buildCommand =
+      "out"
-      ''
+      "stuff"
-        echo impure
+    ];
-        x=$(< $TEST_ROOT/counter)
+    buildCommand = ''
-        mkdir $out $stuff
+      echo impure
-        echo $x > $out/n
+      x=$(< $TEST_ROOT/counter)
-        ln -s $out/n $stuff/bla
+      mkdir $out $stuff
-        printf $((x + 1)) > $TEST_ROOT/counter
+      echo $x > $out/n
-      '';
+      ln -s $out/n $stuff/bla
+      printf $((x + 1)) > $TEST_ROOT/counter
+    '';
     __impure = true;
     impureEnvVars = [ "TEST_ROOT" ];
   };
 
   impureOnImpure = mkDerivation {
     name = "impure-on-impure";
-    buildCommand =
+    buildCommand = ''
-      ''
+      echo impure-on-impure
-        echo impure-on-impure
+      x=$(< ${impure}/n)
-        x=$(< ${impure}/n)
+      mkdir $out
-        mkdir $out
+      printf X$x > $out/n
-        printf X$x > $out/n
+      ln -s ${impure.stuff} $out/symlink
-        ln -s ${impure.stuff} $out/symlink
+      ln -s $out $out/self
-        ln -s $out $out/self
+    '';
-      '';
     __impure = true;
   };
 
   # This is not allowed.
   inputAddressed = mkDerivation {
     name = "input-addressed";
-    buildCommand =
+    buildCommand = ''
-      ''
+      cat ${impure} > $out
-        cat ${impure} > $out
+    '';
-      '';
   };
 
   contentAddressed = mkDerivation {
     name = "content-addressed";
-    buildCommand =
+    buildCommand = ''
-      ''
+      echo content-addressed
-        echo content-addressed
+      x=$(< ${impureOnImpure}/n)
-        x=$(< ${impureOnImpure}/n)
+      printf ''${x:0:1} > $out
-        printf ''${x:0:1} > $out
+    '';
-      '';
     outputHashMode = "recursive";
     outputHash = "sha256-eBYxcgkuWuiqs4cKNgKwkb3vY/HR0vVsJnqe8itJGcQ=";
   };
 
   inputAddressedAfterCA = mkDerivation {
     name = "input-addressed-after-ca";
-    buildCommand =
+    buildCommand = ''
-      ''
+      cat ${contentAddressed} > $out
-        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,55 +10,56 @@ 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) ]
-      (garbage (10 * salt + 1) (n - 1))
+    else
-      (garbage (10 * salt - 1) (n - 1))
+      [
-      (garbage (10 * salt + 2) (n - 1))
+        (garbage (10 * salt + 1) (n - 1))
-      (garbage (10 * salt - 2) (n - 1))
+        (garbage (10 * salt - 1) (n - 1))
-      (garbage (10 * salt + 3) (n - 1))
+        (garbage (10 * salt + 2) (n - 1))
-      (garbage (10 * salt - 3) (n - 1))
+        (garbage (10 * salt - 2) (n - 1))
-      (garbage (10 * salt + 4) (n - 1))
+        (garbage (10 * salt + 3) (n - 1))
-      (garbage (10 * salt - 4) (n - 1))
+        (garbage (10 * salt - 3) (n - 1))
-      (garbage (10 * salt + 5) (n - 1))
+        (garbage (10 * salt + 4) (n - 1))
-      (garbage (10 * salt - 5) (n - 1))
+        (garbage (10 * salt - 4) (n - 1))
-    ];
+        (garbage (10 * salt + 5) (n - 1))
+        (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 3) == pow 10 3;
-  assert sumNestedLists (garbage 0 6) == pow 10 6;
+assert sumNestedLists (garbage 0 6) == pow 10 6;
-  builtins.foldl'
+builtins.foldl'
-    (a: b:
+  (
-      assert
+    a: b:
-        "${
+    assert
-          builtins.path {
+      "${builtins.path {
-            path = ./src;
+        path = ./src;
-            filter = path: type:
+        filter =
-              # We're not doing common subexpression elimination, so this reallocates
+          path: type:
-              # the fairly big tree over and over, producing a lot of garbage during
+          # We're not doing common subexpression elimination, so this reallocates
-              # source filtering, whose filter runs in a coroutine.
+          # the fairly big tree over and over, producing a lot of garbage during
-              assert sumNestedLists (garbage 0 3) == pow 10 3;
+          # source filtering, whose filter runs in a coroutine.
-              true;
+          assert sumNestedLists (garbage 0 3) == pow 10 3;
-          }
+          true;
-        }"
+      }}" == "${./src}";
-          == "${./src}";
 
-      # These asserts don't seem necessary, as the lambda value get corrupted first
+    # These asserts don't seem necessary, as the lambda value get corrupted first
-      assert a.okay;
+    assert a.okay;
-      assert b.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-attr-name-type.nix

@@ -1,7 +1,7 @@
 let
   attrs = {
-    puppy.doggy = {};
+    puppy.doggy = { };
   };
   key = 1;
 in
-  attrs.puppy.${key}
+attrs.puppy.${key}

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
+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
-  type  = "github";
+  n = -1;
-  owner = "NixOS";
+in
-  repo  = n;
+builtins.seq n (
-  ref   = "23.05";
+  builtins.flakeRefToString {
-  dir   = "lib";
+    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-list.nix

@@ -1 +1 @@
-8++1
+8 ++ 1