Format Nix code with `nixfmt`

Change-Id: I61efeb666ff7481c05fcb247168290e86a250151

1 files changed, 342 insertions, 255 deletions

diff --git a/flake.nix b/flake.nix
index 77e34fa7f..0e52695f3 100644
--- a/flake.nix
+++ b/flake.nix
@@ -12,10 +12,20 @@
         nixpkgs-stable.follows = "nixpkgs";
       };
     };
-    flake-compat = { url = "github:edolstra/flake-compat"; flake = false; };
+    flake-compat = {
+      url = "github:edolstra/flake-compat";
+      flake = false;
+    };
   };
 
-  outputs = { self, nixpkgs, nixpkgs-regression, pre-commit-hooks, flake-compat }:
+  outputs =
+    {
+      self,
+      nixpkgs,
+      nixpkgs-regression,
+      pre-commit-hooks,
+      flake-compat,
+    }:
 
     let
       inherit (nixpkgs) lib;
@@ -27,73 +37,98 @@
 
       version = lib.fileContents ./.version + versionSuffix;
       versionSuffix =
-        if officialRelease
-        then ""
-        else "pre${builtins.substring 0 8 (self.lastModifiedDate or self.lastModified or "19700101")}_${self.shortRev or "dirty"}";
+        if officialRelease then
+          ""
+        else
+          "pre${
+            builtins.substring 0 8 (self.lastModifiedDate or self.lastModified or "19700101")
+          }_${self.shortRev or "dirty"}";
 
       linux32BitSystems = [ "i686-linux" ];
-      linux64BitSystems = [ "x86_64-linux" "aarch64-linux" ];
+      linux64BitSystems = [
+        "x86_64-linux"
+        "aarch64-linux"
+      ];
       linuxSystems = linux32BitSystems ++ linux64BitSystems;
-      darwinSystems = [ "x86_64-darwin" "aarch64-darwin" ];
+      darwinSystems = [
+        "x86_64-darwin"
+        "aarch64-darwin"
+      ];
       systems = linuxSystems ++ darwinSystems;
 
       crossSystems = [
-        "armv6l-linux" "armv7l-linux"
-        "x86_64-freebsd13" "x86_64-netbsd"
+        "armv6l-linux"
+        "armv7l-linux"
+        "x86_64-freebsd13"
+        "x86_64-netbsd"
       ];
 
-      stdenvs = [ "gccStdenv" "clangStdenv" "stdenv" "libcxxStdenv" "ccacheStdenv" ];
+      stdenvs = [
+        "gccStdenv"
+        "clangStdenv"
+        "stdenv"
+        "libcxxStdenv"
+        "ccacheStdenv"
+      ];
 
       forAllSystems = lib.genAttrs systems;
 
       forAllCrossSystems = lib.genAttrs crossSystems;
 
-      forAllStdenvs = f:
-        lib.listToAttrs
-          (map
-            (stdenvName: {
-              name = "${stdenvName}Packages";
-              value = f stdenvName;
-            })
-            stdenvs);
+      forAllStdenvs =
+        f:
+        lib.listToAttrs (
+          map (stdenvName: {
+            name = "${stdenvName}Packages";
+            value = f stdenvName;
+          }) stdenvs
+        );
 
       # Memoize nixpkgs for different platforms for efficiency.
-      nixpkgsFor = forAllSystems
-        (system: let
-          make-pkgs = crossSystem: stdenv: import nixpkgs {
-            localSystem = {
-              inherit system;
-            };
-            crossSystem = if crossSystem == null then null else {
-              system = crossSystem;
-            } // lib.optionalAttrs (crossSystem == "x86_64-freebsd13") {
-              useLLVM = true;
+      nixpkgsFor = forAllSystems (
+        system:
+        let
+          make-pkgs =
+            crossSystem: stdenv:
+            import nixpkgs {
+              localSystem = {
+                inherit system;
+              };
+              crossSystem =
+                if crossSystem == null then
+                  null
+                else
+                  {
+                    system = crossSystem;
+                  }
+                  // lib.optionalAttrs (crossSystem == "x86_64-freebsd13") { useLLVM = true; };
+              overlays = [
+                (overlayFor (p: p.${stdenv}))
+                (final: prev: { nixfmt = final.callPackage ./nix-support/nixfmt.nix { }; })
+              ];
+
+              config.permittedInsecurePackages = [ "nix-2.13.6" ];
             };
-            overlays = [
-              (overlayFor (p: p.${stdenv}))
-              (final: prev: {
-                nixfmt = final.callPackage ./nix-support/nixfmt.nix {};
-              })
-            ];
-
-            config.permittedInsecurePackages = [ "nix-2.13.6" ];
-          };
           stdenvs = forAllStdenvs (make-pkgs null);
           native = stdenvs.stdenvPackages;
-        in {
+        in
+        {
           inherit stdenvs native;
           static = native.pkgsStatic;
           cross = forAllCrossSystems (crossSystem: make-pkgs crossSystem "stdenv");
-        });
+        }
+      );
 
-      binaryTarball = nix: pkgs:
+      binaryTarball =
+        nix: pkgs:
         let
           inherit (pkgs) buildPackages;
           installerClosureInfo = buildPackages.closureInfo { rootPaths = [ nix ]; };
         in
 
         buildPackages.runCommand "nix-binary-tarball-${version}"
-          { #nativeBuildInputs = lib.optional (system != "aarch64-linux") shellcheck;
+          {
+            #nativeBuildInputs = lib.optional (system != "aarch64-linux") shellcheck;
             meta.description = "Distribution-independent Nix bootstrap binaries for ${pkgs.system}";
           }
           ''
@@ -114,17 +149,18 @@
               $(cat ${installerClosureInfo}/store-paths)
           '';
 
-      overlayFor = getStdenv: final: prev:
+      overlayFor =
+        getStdenv: final: prev:
         let
           currentStdenv = getStdenv final;
-        in {
+        in
+        {
           nixStable = prev.nix;
 
           # Forward from the previous stage as we don’t want it to pick the lowdown override
           nixUnstable = prev.nixUnstable;
 
-          build-release-notes =
-            final.buildPackages.callPackage ./maintainers/build-release-notes.nix { };
+          build-release-notes = final.buildPackages.callPackage ./maintainers/build-release-notes.nix { };
           clangbuildanalyzer = final.buildPackages.callPackage ./misc/clangbuildanalyzer.nix { };
 
           default-busybox-sandbox-shell = final.busybox.override {
@@ -161,8 +197,8 @@
           # for consumers of this flake.
           boehmgc-nix = final.nix.boehmgc-nix;
         };
-
-    in {
+    in
+    {
       # A Nixpkgs overlay that overrides the 'nix' and
       # 'nix.perl-bindings' packages.
       overlays.default = overlayFor (p: p.stdenv);
@@ -172,58 +208,67 @@
         # Binary package for various platforms.
         build = forAllSystems (system: self.packages.${system}.nix);
 
-        rl-next = forAllSystems (system:
+        rl-next = forAllSystems (
+          system:
           let
-            rl-next-check = name: dir:
-              let pkgs = nixpkgsFor.${system}.native;
-              in pkgs.buildPackages.runCommand "test-${name}-release-notes" { } ''
-              LANG=C.UTF-8 ${lib.getExe pkgs.build-release-notes} ${dir} >$out
-            '';
+            rl-next-check =
+              name: dir:
+              let
+                pkgs = nixpkgsFor.${system}.native;
+              in
+              pkgs.buildPackages.runCommand "test-${name}-release-notes" { } ''
+                LANG=C.UTF-8 ${lib.getExe pkgs.build-release-notes} ${dir} >$out
+              '';
           in
-            {
-              user = rl-next-check "rl-next" ./doc/manual/rl-next;
-              dev = rl-next-check "rl-next-dev" ./doc/manual/rl-next-dev;
-            });
+          {
+            user = rl-next-check "rl-next" ./doc/manual/rl-next;
+            dev = rl-next-check "rl-next-dev" ./doc/manual/rl-next-dev;
+          }
+        );
 
         # FIXME(Qyriad): remove this when the migration to Meson has been completed.
         # NOTE: mesonBuildClang depends on mesonBuild depends on build to avoid OOMs
         # on aarch64 builders caused by too many parallel compiler/linker processes.
-        mesonBuild = forAllSystems (system:
-          (self.packages.${system}.nix.override {
-            buildWithMeson = true;
-          }).overrideAttrs (prev: {
+        mesonBuild = forAllSystems (
+          system:
+          (self.packages.${system}.nix.override { buildWithMeson = true; }).overrideAttrs (prev: {
             buildInputs = prev.buildInputs ++ [ self.packages.${system}.nix ];
-          }));
-        mesonBuildClang = forAllSystems (system:
-          (nixpkgsFor.${system}.stdenvs.clangStdenvPackages.nix.override {
-              buildWithMeson = true;
-          }).overrideAttrs (prev: {
-            buildInputs = prev.buildInputs ++ [ self.hydraJobs.mesonBuild.${system} ];
           })
         );
+        mesonBuildClang = forAllSystems (
+          system:
+          (nixpkgsFor.${system}.stdenvs.clangStdenvPackages.nix.override { buildWithMeson = true; })
+          .overrideAttrs
+            (prev: {
+              buildInputs = prev.buildInputs ++ [ self.hydraJobs.mesonBuild.${system} ];
+            })
+        );
 
         # Perl bindings for various platforms.
         perlBindings = forAllSystems (system: nixpkgsFor.${system}.native.nix.perl-bindings);
 
         # Binary tarball for various platforms, containing a Nix store
         # with the closure of 'nix' package.
-        binaryTarball = forAllSystems (system: binaryTarball nixpkgsFor.${system}.native.nix nixpkgsFor.${system}.native);
+        binaryTarball = forAllSystems (
+          system: binaryTarball nixpkgsFor.${system}.native.nix nixpkgsFor.${system}.native
+        );
 
         # docker image with Nix inside
         dockerImage = lib.genAttrs linux64BitSystems (system: self.packages.${system}.dockerImage);
 
         # API docs for Nix's unstable internal C++ interfaces.
-        internal-api-docs = let
-          nixpkgs = nixpkgsFor.x86_64-linux.native;
-          inherit (nixpkgs) pkgs;
-
-          nix = pkgs.callPackage ./package.nix {
-            inherit versionSuffix officialRelease buildUnreleasedNotes;
-            inherit (pkgs) build-release-notes;
-            internalApiDocs = true;
-            busybox-sandbox-shell = pkgs.busybox-sandbox-shell;
-          };
-        in
+        internal-api-docs =
+          let
+            nixpkgs = nixpkgsFor.x86_64-linux.native;
+            inherit (nixpkgs) pkgs;
+
+            nix = pkgs.callPackage ./package.nix {
+              inherit versionSuffix officialRelease buildUnreleasedNotes;
+              inherit (pkgs) build-release-notes;
+              internalApiDocs = true;
+              busybox-sandbox-shell = pkgs.busybox-sandbox-shell;
+            };
+          in
           nix.overrideAttrs (prev: {
             # This Hydra job is just for the internal API docs.
             # We don't need the build artifacts here.
@@ -239,195 +284,237 @@
           # on a particular version of Nixpkgs.
           evalNixpkgs =
             with nixpkgsFor.x86_64-linux.native;
-            runCommand "eval-nixos" { buildInputs = [ nix ]; }
-              ''
-                type -p nix-env
-                # Note: we're filtering out nixos-install-tools because https://github.com/NixOS/nixpkgs/pull/153594#issuecomment-1020530593.
-                time nix-env --store dummy:// -f ${nixpkgs-regression} -qaP --drv-path | sort | grep -v nixos-install-tools > packages
-                [[ $(sha1sum < packages | cut -c1-40) = 402242fca90874112b34718b8199d844e8b03d12 ]]
-                mkdir $out
-              '';
+            runCommand "eval-nixos" { buildInputs = [ nix ]; } ''
+              type -p nix-env
+              # Note: we're filtering out nixos-install-tools because https://github.com/NixOS/nixpkgs/pull/153594#issuecomment-1020530593.
+              time nix-env --store dummy:// -f ${nixpkgs-regression} -qaP --drv-path | sort | grep -v nixos-install-tools > packages
+              [[ $(sha1sum < packages | cut -c1-40) = 402242fca90874112b34718b8199d844e8b03d12 ]]
+              mkdir $out
+            '';
 
-          nixpkgsLibTests =
-            forAllSystems (system:
-              import (nixpkgs + "/lib/tests/release.nix")
-                { pkgs = nixpkgsFor.${system}.native;
-                  nixVersions = [ self.packages.${system}.nix ];
-                }
-            );
+          nixpkgsLibTests = forAllSystems (
+            system:
+            import (nixpkgs + "/lib/tests/release.nix") {
+              pkgs = nixpkgsFor.${system}.native;
+              nixVersions = [ self.packages.${system}.nix ];
+            }
+          );
         };
 
-        pre-commit = builtins.mapAttrs (system: pre-commit-lib: pre-commit-lib.run {
-          src = self;
-          hooks = {
-            no-commit-to-branch = {
-              enable = true;
-              settings.branch = ["main"];
-            };
-            check-case-conflicts.enable = true;
-            check-executables-have-shebangs = {
-              enable = true;
-              stages = [ "commit" ];
-            };
-            check-shebang-scripts-are-executable = {
-              enable = true;
-              stages = [ "commit" ];
-            };
-            check-symlinks = {
-              enable = true;
-              excludes = [ "^tests/functional/lang/symlink-resolution/broken$" ];
-            };
-            check-merge-conflicts.enable = true;
-            end-of-file-fixer = {
-              enable = true;
-              excludes = [
-                "\\.drv$"
-                "^tests/functional/lang/"
-              ];
-            };
-            mixed-line-endings = {
-              enable = true;
-              excludes = [ "^tests/functional/lang/" ];
-            };
-            # TODO: Once the test suite is nicer, clean up and start
-            # enforcing trailing whitespace on tests that don't explicitly
-            # check for it.
-            trim-trailing-whitespace = {
-              enable = true;
-              stages = [ "commit" ];
-              excludes = [ "^tests/functional/lang/" ];
-            };
-            treefmt = {
-              enable = true;
-              settings.formatters =
-                let
-                  pkgs = nixpkgsFor.${system}.native;
-                in
-                [ pkgs.nixfmt ];
+        pre-commit = builtins.mapAttrs (
+          system: pre-commit-lib:
+          pre-commit-lib.run {
+            src = self;
+            hooks = {
+              no-commit-to-branch = {
+                enable = true;
+                settings.branch = [ "main" ];
+              };
+              check-case-conflicts.enable = true;
+              check-executables-have-shebangs = {
+                enable = true;
+                stages = [ "commit" ];
+              };
+              check-shebang-scripts-are-executable = {
+                enable = true;
+                stages = [ "commit" ];
+              };
+              check-symlinks = {
+                enable = true;
+                excludes = [ "^tests/functional/lang/symlink-resolution/broken$" ];
+              };
+              check-merge-conflicts.enable = true;
+              end-of-file-fixer = {
+                enable = true;
+                excludes = [
+                  "\\.drv$"
+                  "^tests/functional/lang/"
+                ];
+              };
+              mixed-line-endings = {
+                enable = true;
+                excludes = [ "^tests/functional/lang/" ];
+              };
+              # TODO: Once the test suite is nicer, clean up and start
+              # enforcing trailing whitespace on tests that don't explicitly
+              # check for it.
+              trim-trailing-whitespace = {
+                enable = true;
+                stages = [ "commit" ];
+                excludes = [ "^tests/functional/lang/" ];
+              };
+              treefmt = {
+                enable = true;
+                settings.formatters =
+                  let
+                    pkgs = nixpkgsFor.${system}.native;
+                  in
+                  [ pkgs.nixfmt ];
+              };
             };
-          };
-        }) pre-commit-hooks.lib;
+          }
+        ) pre-commit-hooks.lib;
       };
 
       # NOTE *do not* add fresh derivations to checks, always add them to
       # hydraJobs first (so CI will pick them up) and only link them here
-      checks = forAllSystems (system: {
-        # FIXME(Qyriad): remove this when the migration to Meson has been completed.
-        mesonBuild = self.hydraJobs.mesonBuild.${system};
-        mesonBuildClang = self.hydraJobs.mesonBuildClang.${system};
-        binaryTarball = self.hydraJobs.binaryTarball.${system};
-        perlBindings = self.hydraJobs.perlBindings.${system};
-        nixpkgsLibTests = self.hydraJobs.tests.nixpkgsLibTests.${system};
-        rl-next = self.hydraJobs.rl-next.${system}.user;
-        rl-next-dev = self.hydraJobs.rl-next.${system}.dev;
-        pre-commit = self.hydraJobs.pre-commit.${system};
-      } // (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
-        dockerImage = self.hydraJobs.dockerImage.${system};
-      });
-
-      packages = forAllSystems (system: rec {
-        inherit (nixpkgsFor.${system}.native) nix;
-        default = nix;
-      } // (lib.optionalAttrs (builtins.elem system linux64BitSystems) {
-        nix-static = nixpkgsFor.${system}.static.nix;
-        dockerImage =
-          let
-            pkgs = nixpkgsFor.${system}.native;
-            image = import ./docker.nix { inherit pkgs; tag = version; };
-          in
-          pkgs.runCommand
-            "docker-image-tarball-${version}"
-            { meta.description = "Docker image with Nix for ${system}"; }
-            ''
-              mkdir -p $out/nix-support
-              image=$out/image.tar.gz
-              ln -s ${image} $image
-              echo "file binary-dist $image" >> $out/nix-support/hydra-build-products
-            '';
-      } // builtins.listToAttrs (map
-          (crossSystem: {
-            name = "nix-${crossSystem}";
-            value = nixpkgsFor.${system}.cross.${crossSystem}.nix;
-          })
-          crossSystems)
-        // builtins.listToAttrs (map
-          (stdenvName: {
-            name = "nix-${stdenvName}";
-            value = nixpkgsFor.${system}.stdenvs."${stdenvName}Packages".nix;
-          })
-          stdenvs)));
-
-      devShells = let
-        makeShell = pkgs: stdenv:
-          let
-            nix = pkgs.callPackage ./package.nix {
-              inherit stdenv versionSuffix;
-              busybox-sandbox-shell = pkgs.busybox-sandbox-shell or pkgs.default-busybox-sandbox;
-              forDevShell = true;
-            };
-            pre-commit = self.hydraJobs.pre-commit.${pkgs.system} or {};
-          in
+      checks = forAllSystems (
+        system:
+        {
+          # FIXME(Qyriad): remove this when the migration to Meson has been completed.
+          mesonBuild = self.hydraJobs.mesonBuild.${system};
+          mesonBuildClang = self.hydraJobs.mesonBuildClang.${system};
+          binaryTarball = self.hydraJobs.binaryTarball.${system};
+          perlBindings = self.hydraJobs.perlBindings.${system};
+          nixpkgsLibTests = self.hydraJobs.tests.nixpkgsLibTests.${system};
+          rl-next = self.hydraJobs.rl-next.${system}.user;
+          rl-next-dev = self.hydraJobs.rl-next.${system}.dev;
+          pre-commit = self.hydraJobs.pre-commit.${system};
+        }
+        // (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
+          dockerImage = self.hydraJobs.dockerImage.${system};
+        }
+      );
+
+      packages = forAllSystems (
+        system:
+        rec {
+          inherit (nixpkgsFor.${system}.native) nix;
+          default = nix;
+        }
+        // (
+          lib.optionalAttrs (builtins.elem system linux64BitSystems) {
+            nix-static = nixpkgsFor.${system}.static.nix;
+            dockerImage =
+              let
+                pkgs = nixpkgsFor.${system}.native;
+                image = import ./docker.nix {
+                  inherit pkgs;
+                  tag = version;
+                };
+              in
+              pkgs.runCommand "docker-image-tarball-${version}"
+                { meta.description = "Docker image with Nix for ${system}"; }
+                ''
+                  mkdir -p $out/nix-support
+                  image=$out/image.tar.gz
+                  ln -s ${image} $image
+                  echo "file binary-dist $image" >> $out/nix-support/hydra-build-products
+                '';
+          }
+          // builtins.listToAttrs (
+            map (crossSystem: {
+              name = "nix-${crossSystem}";
+              value = nixpkgsFor.${system}.cross.${crossSystem}.nix;
+            }) crossSystems
+          )
+          // builtins.listToAttrs (
+            map (stdenvName: {
+              name = "nix-${stdenvName}";
+              value = nixpkgsFor.${system}.stdenvs."${stdenvName}Packages".nix;
+            }) stdenvs
+          )
+        )
+      );
+
+      devShells =
+        let
+          makeShell =
+            pkgs: stdenv:
+            let
+              nix = pkgs.callPackage ./package.nix {
+                inherit stdenv versionSuffix;
+                busybox-sandbox-shell = pkgs.busybox-sandbox-shell or pkgs.default-busybox-sandbox;
+                forDevShell = true;
+              };
+              pre-commit = self.hydraJobs.pre-commit.${pkgs.system} or { };
+            in
             (nix.override {
               buildUnreleasedNotes = true;
               officialRelease = false;
-            }).overrideAttrs (prev: {
-              # Required for clang-tidy checks
-              buildInputs = prev.buildInputs
-                ++ [ pkgs.just pkgs.nixfmt ]
-                ++ lib.optional (pre-commit ? enabledPackages) pre-commit.enabledPackages
-                ++ lib.optionals (stdenv.cc.isClang) [ pkgs.llvmPackages.llvm pkgs.llvmPackages.clang-unwrapped.dev ];
-              nativeBuildInputs = prev.nativeBuildInputs
-                ++ lib.optional (stdenv.cc.isClang && !stdenv.buildPlatform.isDarwin) pkgs.buildPackages.bear
-                # Required for clang-tidy checks
-                ++ lib.optionals (stdenv.cc.isClang) [ pkgs.buildPackages.cmake pkgs.buildPackages.ninja pkgs.buildPackages.llvmPackages.llvm.dev ]
-                ++ lib.optional
-                  (stdenv.cc.isClang && stdenv.hostPlatform == stdenv.buildPlatform)
-                  # for some reason that seems accidental and was changed in
-                  # NixOS 24.05-pre, clang-tools is pinned to LLVM 14 when
-                  # default LLVM is newer.
-                  (pkgs.buildPackages.clang-tools.override { inherit (pkgs.buildPackages) llvmPackages; })
-                ++ [
-                  # FIXME(Qyriad): remove once the migration to Meson is complete.
-                  pkgs.buildPackages.meson
-                  pkgs.buildPackages.ninja
-                  pkgs.buildPackages.cmake
-
-                  pkgs.buildPackages.clangbuildanalyzer
-                ];
-
-              src = null;
-
-              installFlags = "sysconfdir=$(out)/etc";
-              strictDeps = false;
-
-              shellHook = ''
-                PATH=$prefix/bin:$PATH
-                unset PYTHONPATH
-                export MANPATH=$out/share/man:$MANPATH
-
-                # Make bash completion work.
-                XDG_DATA_DIRS+=:$out/share
-
-                ${lib.optionalString (pre-commit ? shellHook) pre-commit.shellHook}
-              '';
-            } // lib.optionalAttrs (stdenv.buildPlatform.isLinux && pkgs.glibcLocales != null) {
-              # Required to make non-NixOS Linux not complain about missing locale files during configure in a dev shell
-              LOCALE_ARCHIVE = "${lib.getLib pkgs.glibcLocales}/lib/locale/locale-archive";
-            });
+            }).overrideAttrs
+              (
+                prev:
+                {
+                  # Required for clang-tidy checks
+                  buildInputs =
+                    prev.buildInputs
+                    ++ [
+                      pkgs.just
+                      pkgs.nixfmt
+                    ]
+                    ++ lib.optional (pre-commit ? enabledPackages) pre-commit.enabledPackages
+                    ++ lib.optionals (stdenv.cc.isClang) [
+                      pkgs.llvmPackages.llvm
+                      pkgs.llvmPackages.clang-unwrapped.dev
+                    ];
+                  nativeBuildInputs =
+                    prev.nativeBuildInputs
+                    ++ lib.optional (stdenv.cc.isClang && !stdenv.buildPlatform.isDarwin) pkgs.buildPackages.bear
+                    # Required for clang-tidy checks
+                    ++ lib.optionals (stdenv.cc.isClang) [
+                      pkgs.buildPackages.cmake
+                      pkgs.buildPackages.ninja
+                      pkgs.buildPackages.llvmPackages.llvm.dev
+                    ]
+                    ++
+                      lib.optional (stdenv.cc.isClang && stdenv.hostPlatform == stdenv.buildPlatform)
+                        # for some reason that seems accidental and was changed in
+                        # NixOS 24.05-pre, clang-tools is pinned to LLVM 14 when
+                        # default LLVM is newer.
+                        (pkgs.buildPackages.clang-tools.override { inherit (pkgs.buildPackages) llvmPackages; })
+                    ++ [
+                      # FIXME(Qyriad): remove once the migration to Meson is complete.
+                      pkgs.buildPackages.meson
+                      pkgs.buildPackages.ninja
+                      pkgs.buildPackages.cmake
+
+                      pkgs.buildPackages.clangbuildanalyzer
+                    ];
+
+                  src = null;
+
+                  installFlags = "sysconfdir=$(out)/etc";
+                  strictDeps = false;
+
+                  shellHook = ''
+                    PATH=$prefix/bin:$PATH
+                    unset PYTHONPATH
+                    export MANPATH=$out/share/man:$MANPATH
+
+                    # Make bash completion work.
+                    XDG_DATA_DIRS+=:$out/share
+
+                    ${lib.optionalString (pre-commit ? shellHook) pre-commit.shellHook}
+                  '';
+                }
+                // lib.optionalAttrs (stdenv.buildPlatform.isLinux && pkgs.glibcLocales != null) {
+                  # Required to make non-NixOS Linux not complain about missing locale files during configure in a dev shell
+                  LOCALE_ARCHIVE = "${lib.getLib pkgs.glibcLocales}/lib/locale/locale-archive";
+                }
+              );
         in
-        forAllSystems (system:
+        forAllSystems (
+          system:
           let
-            makeShells = prefix: pkgs:
-              lib.mapAttrs'
-              (k: v: lib.nameValuePair "${prefix}-${k}" v)
-              (forAllStdenvs (stdenvName: makeShell pkgs pkgs.${stdenvName}));
+            makeShells =
+              prefix: pkgs:
+              lib.mapAttrs' (k: v: lib.nameValuePair "${prefix}-${k}" v) (
+                forAllStdenvs (stdenvName: makeShell pkgs pkgs.${stdenvName})
+              );
           in
-            (makeShells "native" nixpkgsFor.${system}.native) //
-            (makeShells "static" nixpkgsFor.${system}.static) //
-            (forAllCrossSystems (crossSystem: let pkgs = nixpkgsFor.${system}.cross.${crossSystem}; in makeShell pkgs pkgs.stdenv)) //
-            {
-              default = self.devShells.${system}.native-stdenvPackages;
-            }
+          (makeShells "native" nixpkgsFor.${system}.native)
+          // (makeShells "static" nixpkgsFor.${system}.static)
+          // (forAllCrossSystems (
+            crossSystem:
+            let
+              pkgs = nixpkgsFor.${system}.cross.${crossSystem};
+            in
+            makeShell pkgs pkgs.stdenv
+          ))
+          // {
+            default = self.devShells.${system}.native-stdenvPackages;
+          }
         );
-  };
+    };
 }