flake.nix

{
  description = "The purely functional package manager";

  inputs.nixpkgs.url = "https://channels.nixos.org/nixos-26.05/nixexprs.tar.xz";

  inputs.nixpkgs-regression.url = "github:NixOS/nixpkgs/215d4d0fd80ca5163643b03a33fde804a29cc1e2";
  inputs.nixpkgs-23-11.url = "github:NixOS/nixpkgs/a62e6edd6d5e1fa0329b8653c801147986f8d446";
  inputs.flake-compat = {
    url = "github:NixOS/flake-compat";
    flake = false;
  };

  # dev tooling
  inputs.flake-parts.url = "github:hercules-ci/flake-parts";
  inputs.git-hooks-nix.url = "github:cachix/git-hooks.nix";
  # work around https://github.com/NixOS/nix/issues/7730
  inputs.flake-parts.inputs.nixpkgs-lib.follows = "nixpkgs";
  inputs.git-hooks-nix.inputs.nixpkgs.follows = "nixpkgs";
  # work around 7730 and https://github.com/NixOS/nix/issues/7807
  inputs.git-hooks-nix.inputs.flake-compat.follows = "";

  outputs =
    inputs@{
      self,
      nixpkgs,
      nixpkgs-regression,
      ...
    }:

    let
      inherit (nixpkgs) lib;

      officialRelease = false;

      linux32BitSystems = [ "i686-linux" ];
      linux64BitSystems = [
        "x86_64-linux"
        "aarch64-linux"
      ];
      linuxSystems = linux32BitSystems ++ linux64BitSystems;
      darwinSystems = [
        "aarch64-darwin"
      ];
      systems = linuxSystems ++ darwinSystems;

      crossSystems = [
        "armv6l-unknown-linux-gnueabihf"
        "armv7l-unknown-linux-gnueabihf"
        "powerpc64-unknown-linux-gnuabielfv1"
        "powerpc64le-unknown-linux-gnu"
        "riscv64-unknown-linux-gnu"
        # Disabled because of https://github.com/NixOS/nixpkgs/issues/344423
        # "x86_64-unknown-netbsd"
        "x86_64-unknown-freebsd"
        "x86_64-w64-mingw32"
      ];

      stdenvs = [
        "ccacheStdenv"
        "clangStdenv"
        "gccStdenv"
        "libcxxStdenv"
        "stdenv"
      ];

      /**
        `flatMapAttrs attrs f` applies `f` to each attribute in `attrs` and
        merges the results into a single attribute set.

        This can be nested to form a build matrix where all the attributes
        generated by the innermost `f` are returned as is.
        (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;

      forAllCrossSystems = lib.genAttrs crossSystems;

      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, ... }:
          {
            _module.args.pkgs = nixpkgsFor.${system}.native;
          };
      };

      /**
        Memoized nixpkgs for different platforms for efficiency.
      */
      nixpkgsFor = forAllSystems (
        system:
        let
          makePkgs =
            crossSystem:
            import nixpkgs {
              localSystem = {
                inherit system;
              };
              crossSystem =
                if crossSystem == null then
                  null
                else
                  {
                    config = crossSystem;
                  }
                  // lib.optionalAttrs (crossSystem == "x86_64-w64-mingw32") {
                    emulator = pkgs: "${pkgs.buildPackages.wineWow64Packages.stable}/bin/wine";
                  };
            };
        in
        {
          native = makePkgs null;
          cross = forAllCrossSystems makePkgs;
        }
      );

      /**
        Memoised nix component scopes for different platforms and stdenvs.
      */
      nixComponentsFor = forAllSystems (
        system:
        let
          pkgs = nixpkgsFor.${system}.native;
          makePackageSet =
            pkgs: stdenv:
            (packageSetsFor {
              inherit pkgs;
              getStdenv = pkgs: pkgs.${stdenv};
            }).nixComponents
            // {
              # This is not the nixpkgs fixpoint, but just for easier plubming in hydraJobs and such.
              # Technically you can extract the fixpoint with `callPackage {pkgs}: pkgs`, but that's
              # a little too verbose. And in hydraJobs and flake output definitions no overriding should
              # happen anyway.
              _pkgs = pkgs;
            };
        in
        rec {
          nativeForStdenv = forAllStdenvs (stdenv: makePackageSet pkgs stdenv);
          nativeStaticForStdenv = forAllStdenvs (
            stdenv: makePackageSet nixpkgsFor.${system}.native.pkgsStatic stdenv
          );
          nativeLLVMForStdenv = forAllStdenvs (
            stdenv: makePackageSet nixpkgsFor.${system}.native.pkgsLLVM stdenv
          );
          native = nativeForStdenv.stdenv;
          cross = forAllCrossSystems (
            crossSystem: makePackageSet nixpkgsFor.${system}.cross.${crossSystem} "stdenv"
          );
          nativeStatic = nativeStaticForStdenv.stdenv;
          nativeLLVM = nativeLLVMForStdenv.stdenv;
        }
      );

      /**
        Produce the `nixComponents` and `nixDependencies` package sets (scopes) for
        a given `pkgs` and `getStdenv`.
      */
      packageSetsFor =
        (import ./packaging/scopes.nix {
          inherit officialRelease lib;
          src = self;
        }).packageSetsFor;
    in
    {
      /**
        A Nixpkgs overlay that sets `nix` to something like `packages.<system>.nix-everything`,
        except dependencies aren't taken from (flake) `nix.inputs.nixpkgs`, but from the Nixpkgs packages
        where the overlay is used.
      */
      overlays.default =
        final: prev:
        let
          packageSets = packageSetsFor { pkgs = final; };
        in
        {
          nix = packageSets.nixComponents.nix-everything;
        };

      hydraJobs = import ./packaging/hydra.nix {
        inherit
          inputs
          forAllCrossSystems
          forAllSystems
          lib
          linux64BitSystems
          nixpkgsFor
          nixComponentsFor
          self
          ;
      };

      checks = forAllSystems (
        system:
        (import ./ci/gha/tests {
          inherit system;
          pkgs = nixpkgsFor.${system}.native;
          nixFlake = self;
        }).topLevel
        // (lib.optionalAttrs (builtins.elem system linux64BitSystems)) {
          dockerImage = self.hydraJobs.dockerImage.${system};
        }
        // (lib.optionalAttrs (system == "x86_64-linux")) {
          fuzzing-engine = nixpkgsFor.${system}.native.callPackage ./tests/fuzzing-engine { };
        }
        # Add "passthru" tests
        //
          flatMapAttrs
            {
              "" = {
                pkgs = nixpkgsFor.${system}.native;
              };
            }
            (
              nixpkgsPrefix: args:
              (import ./ci/gha/tests (
                args
                // {
                  nixFlake = self;
                  componentTestsPrefix = nixpkgsPrefix;
                }
              )).componentTests
            )
        // devFlake.checks.${system} or { }
      );

      packages = forAllSystems (
        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
            ;
          installerScriptForGHA = self.hydraJobs.installerScriptForGHA.${system};
          binaryTarball = self.hydraJobs.binaryTarball.${system};
          # TODO probably should be `nix-cli`
          nix = nixComponentsFor.${system}.native.nix-everything;
          default = nixComponentsFor.${system}.native.nix-everything;
          inherit (nixComponentsFor.${system}.native)
            nix-manual
            nix-manual-manpages-only
            nix-internal-api-docs
            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
              "nix-util" = { };
              "nix-util-c" = { };
              "nix-util-test-support" = { };
              "nix-util-tests" = { };

              "nix-store" = { };
              "nix-store-c" = { };
              "nix-store-test-support" = { };
              "nix-store-tests" = { };

              "nix-fetchers" = { };
              "nix-fetchers-c" = { };
              "nix-fetchers-tests" = { };

              "nix-expr" = { };
              "nix-expr-c" = { };
              "nix-expr-test-support" = { };
              "nix-expr-tests" = { };

              "nix-flake" = { };
              "nix-flake-c" = { };
              "nix-flake-tests" = { };

              "nix-main" = { };
              "nix-main-c" = { };

              "nix-cmd" = { };

              "nix-nswrapper" = {
                linuxOnly = true;
              };

              "nix-cli" = { };

              "nix-everything" = { };

              "nix-functional-tests" = {
                supportsCross = false;
              };

              "nix-json-schema-checks" = {
                supportsCross = false;
              };

              "nix-clang-tidy-plugin" = {
                supportsCross = false;
              };
            }
            (
              pkgName:
              {
                supportsCross ? true,
                linuxOnly ? false,
              }:
              lib.optionalAttrs (linuxOnly -> nixpkgsFor.${system}.native.stdenv.hostPlatform.isLinux) (
                {
                  # These attributes go right into `packages.<system>`.
                  "${pkgName}" = nixComponentsFor.${system}.native.${pkgName};
                  "${pkgName}-static" = nixComponentsFor.${system}.nativeStatic.${pkgName};
                  # FIXME: These don't actually evaluate on darwin.
                  "${pkgName}-llvm" = nixComponentsFor.${system}.nativeLLVM.${pkgName};
                }
                // flatMapAttrs (lib.genAttrs stdenvs (_: { })) (
                  stdenvName:
                  { }:
                  {
                    # These attributes go right into `packages.<system>`.
                    "${pkgName}-${stdenvName}" = nixComponentsFor.${system}.nativeForStdenv.${stdenvName}.${pkgName};
                  }
                )
              )
              // lib.optionalAttrs supportsCross (
                flatMapAttrs (lib.genAttrs crossSystems (_: { })) (
                  crossSystem:
                  { }:
                  lib.optionalAttrs
                    (linuxOnly -> nixpkgsFor.${system}.cross.${crossSystem}.stdenv.hostPlatform.isLinux)
                    {
                      # These attributes go right into `packages.<system>`.
                      "${pkgName}-${crossSystem}" = nixComponentsFor.${system}.cross.${crossSystem}.${pkgName};
                    }
                )
              )
            )
        // lib.optionalAttrs (self.hydraJobs.nixInstaller ? ${system}) {
          nixInstaller = self.hydraJobs.nixInstaller.${system};
        }
        // lib.optionalAttrs (self.hydraJobs.dockerImage ? ${system}) {
          dockerImage = self.hydraJobs.dockerImage.${system};
        }
      );

      apps = forAllSystems (
        system:
        let
          pkgs = nixpkgsFor.${system}.native;
          opener = if pkgs.stdenv.isDarwin then "open" else "xdg-open";
        in
        {
          open-manual = {
            type = "app";
            program = "${pkgs.writeShellScript "open-nix-manual" ''
              path="${self.packages.${system}.nix-manual.site}/index.html"
              if ! ${opener} "$path"; then
                echo "Failed to open manual with ${opener}. Manual is located at:"
                echo "$path"
              fi
            ''}";
            meta.description = "Open the Nix manual in your browser";
          };
        }
      );

      devShells =
        let
          makeShell = import ./packaging/dev-shell.nix { inherit lib devFlake; };
          makeShell' =
            components:
            makeShell {
              pkgs = components._pkgs;
              nixComponents = components.overrideScope (
                finalScope: prevScope: {
                  withUnityBuild = false;
                }
              );
            };
          prefixAttrs = prefix: lib.concatMapAttrs (k: v: { "${prefix}-${k}" = v; });
        in
        forAllSystems (
          system:
          prefixAttrs "native" (
            forAllStdenvs (stdenvName: makeShell' nixComponentsFor.${system}.nativeForStdenv.${stdenvName})
          )
          // lib.optionalAttrs (!nixpkgsFor.${system}.native.stdenv.isDarwin) (
            prefixAttrs "static" (
              forAllStdenvs (
                stdenvName: makeShell' nixComponentsFor.${system}.nativeStaticForStdenv.${stdenvName}
              )
            )
            // prefixAttrs "llvm" (
              forAllStdenvs (stdenvName: makeShell' nixComponentsFor.${system}.nativeLLVMForStdenv.${stdenvName})
            )
            // prefixAttrs "cross" (
              forAllCrossSystems (crossSystem: makeShell' nixComponentsFor.${system}.cross.${crossSystem})
            )
          )
          // {
            native = self.devShells.${system}.native-stdenv;
            default = self.devShells.${system}.native;
          }
        );

      lib = {
        /**
          Creates a package set for a given Nixpkgs instance and stdenv.

          # Inputs

          - `pkgs`: The Nixpkgs instance to use.

          - `getStdenv`: _Optional_ A function that takes a package set and returns the stdenv to use.
            This needs to be a function in order to support cross compilation - the `pkgs` passed to `getStdenv` can be `pkgsBuildHost` or any other variation needed.

          # Outputs

          The return value is a fresh Nixpkgs scope containing all the packages that are defined in the Nix repository,
          as well as some internals and parameters, which may be subject to change.

          # Example

          ```console
          nix repl> :lf NixOS/nix
          nix-repl> ps = lib.makeComponents { pkgs = import inputs.nixpkgs { crossSystem = "riscv64-linux"; }; }
          nix-repl> ps
          {
            appendPatches = «lambda appendPatches @ ...»;
            callPackage = «lambda callPackageWith @ ...»;
            overrideAllMesonComponents = «lambda overrideSource @ ...»;
            overrideSource = «lambda overrideSource @ ...»;
            # ...
            nix-everything
            # ...
            nix-store
            nix-store-c
            # ...
          }
          ```
        */
        makeComponents =
          {
            pkgs,
            getStdenv ? pkgs: pkgs.stdenv,
          }:

          let
            packageSets = packageSetsFor { inherit getStdenv pkgs; };
          in
          packageSets.nixComponents;
      };
    };
}