haskellPackages: stackage LTS 23.24 -> LTS 23.27

doc/languages-frameworks/agda.section.md

@@ -125,11 +125,10 @@ To install Agda without GHC, use `ghc = null;`.
 
 ## Writing Agda packages {#writing-agda-packages}
 
-To write a nix derivation for an Agda library, first check that the library has a `*.agda-lib` file.
+To write a nix derivation for an Agda library, first check that the library has a (single) `*.agda-lib` file.
 
 A derivation can then be written using `agdaPackages.mkDerivation`. This has similar arguments to `stdenv.mkDerivation` with the following additions:
 
-* `everythingFile` can be used to specify the location of the `Everything.agda` file, defaulting to `./Everything.agda`. If this file does not exist then either it should be patched in or the `buildPhase` should be overridden (see below).
 * `libraryName` should be the name that appears in the `*.agda-lib` file, defaulting to `pname`.
 * `libraryFile` should be the file name of the `*.agda-lib` file, defaulting to `${libraryName}.agda-lib`.
 
@@ -150,9 +149,9 @@ agdaPackages.mkDerivation {
 
 ### Building Agda packages {#building-agda-packages}
 
-The default build phase for `agdaPackages.mkDerivation` runs `agda` on the `Everything.agda` file.
+The default build phase for `agdaPackages.mkDerivation` runs `agda --build-library`.
 If something else is needed to build the package (e.g. `make`) then the `buildPhase` should be overridden.
-Additionally, a `preBuild` or `configurePhase` can be used if there are steps that need to be done prior to checking the `Everything.agda` file.
+Additionally, a `preBuild` or `configurePhase` can be used if there are steps that need to be done prior to checking the library.
 `agda` and the Agda libraries contained in `buildInputs` are made available during the build phase.
 
 ### Installing Agda packages {#installing-agda-packages}
@@ -180,53 +179,37 @@ the Agda package set is small and can (still) be maintained by hand.
 
 ### Adding Agda packages to Nixpkgs {#adding-agda-packages-to-nixpkgs}
 
-To add an Agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other Agda libraries, so the top line of the `default.nix` can look like:
+To add an Agda package to `nixpkgs`, the derivation should be written to `pkgs/development/libraries/agda/${library-name}/default.nix` and an entry should be added to `pkgs/top-level/agda-packages.nix`. Here it is called in a scope with access to all other Agda libraries, so the derivation could look like:
 
 ```nix
 {
   mkDerivation,
   standard-library,
   fetchFromGitHub,
 }:
-{ }
-```
-
-Note that the derivation function is called with `mkDerivation` set to `agdaPackages.mkDerivation`, therefore you
-could use a similar set as in your `default.nix` from [Writing Agda Packages](#writing-agda-packages) with
-`agdaPackages.mkDerivation` replaced with `mkDerivation`.
 
-Here is an example skeleton derivation for iowa-stdlib:
-
-```nix
 mkDerivation {
-  version = "1.5.0";
-  pname = "iowa-stdlib";
-
+  pname = "my-library";
+  version = "1.0";
   src = <...>;
-
-  libraryFile = "";
-  libraryName = "IAL-1.3";
-
-  buildPhase = ''
-    runHook preBuild
-
-    patchShebangs find-deps.sh
-    make
-
-    runHook postBuild
-  '';
+  buildInputs = [ standard-library ];
+  meta = <...>;
 }
 ```
 
-This library has a file called `.agda-lib`, and so we give an empty string to `libraryFile` as nothing precedes `.agda-lib` in the filename. This file contains `name: IAL-1.3`, and so we let `libraryName =  "IAL-1.3"`. This library does not use an `Everything.agda` file and instead has a Makefile, so there is no need to set `everythingFile` and we set a custom `buildPhase`.
+You can look at other files under `pkgs/development/libraries/agda/` for more inspiration.
+
+Note that the derivation function is called with `mkDerivation` set to `agdaPackages.mkDerivation`, therefore you
+could use a similar set as in your `default.nix` from [Writing Agda Packages](#writing-agda-packages) with
+`agdaPackages.mkDerivation` replaced with `mkDerivation`.
 
 When writing an Agda package it is essential to make sure that no `.agda-lib` file gets added to the store as a single file (for example by using `writeText`). This causes Agda to think that the nix store is a Agda library and it will attempt to write to it whenever it typechecks something. See [https://github.com/agda/agda/issues/4613](https://github.com/agda/agda/issues/4613).
 
 In the pull request adding this library,
 you can test whether it builds correctly by writing in a comment:
 
 ```
-@ofborg build agdaPackages.iowa-stdlib
+@ofborg build agdaPackages.my-library
 ```
 
 ### Maintaining Agda packages {#agda-maintaining-packages}

maintainers/scripts/haskell/merge-and-open-pr.sh

@@ -80,13 +80,7 @@ echo "Merging https://github.com/NixOS/nixpkgs/pull/${curr_haskell_updates_pr_nu
 gh pr merge --repo NixOS/nixpkgs --merge "$curr_haskell_updates_pr_num"
 
 # Update stackage, Hackage hashes, and regenerate Haskell package set
-echo "Updating Stackage..."
-./maintainers/scripts/haskell/update-stackage.sh --do-commit
-echo "Updating Hackage hashes..."
-./maintainers/scripts/haskell/update-hackage.sh --do-commit
-echo "Regenerating Hackage packages..."
-# Using fast here because after the hackage-update eval errors will likely break the transitive dependencies check.
-./maintainers/scripts/haskell/regenerate-hackage-packages.sh --fast --do-commit
+./maintainers/scripts/haskell/update-package-set.sh
 
 # Push these new commits to the haskell-updates branch
 echo "Pushing commits just created to the remote $push_remote/haskell-updates branch..."

maintainers/scripts/haskell/regenerate-hackage-packages.sh

@@ -107,10 +107,10 @@ nixfmt pkgs/development/haskell-modules/hackage-packages.nix
 if [[ "$DO_COMMIT" -eq 1 ]]; then
 git add pkgs/development/haskell-modules/configuration-hackage2nix/transitive-broken.yaml
 git add pkgs/development/haskell-modules/hackage-packages.nix
-git commit -F - << EOF
+git commit --edit -F - << EOF
 haskellPackages: regenerate package set based on current config
 
-This commit has been generated by maintainers/scripts/haskell/regenerate-hackage-packages.sh
+(generated by maintainers/scripts/haskell/regenerate-hackage-packages.sh)
 EOF
 fi
 

maintainers/scripts/haskell/update-hackage.sh

@@ -1,10 +1,34 @@
 #! /usr/bin/env nix-shell
 #! nix-shell -i bash -p curl jq git gnused -I nixpkgs=.
-
-# See regenerate-hackage-packages.sh for details on the purpose of this script.
+#
+# SYNOPSIS
+#
+#   Update Hackage index and hashes data exposed via pkgs.all-cabal-hashes.
+#
+# DESCRIPTION
+#
+#   Find latest revision of the commercialhaskell/all-cabal-hashes repository's
+#   hackage branch and update pkgs/data/misc/hackage/pin.json accordingly.
+#
+#   This data is used by hackage2nix to generate hackage-packages.nix. Since
+#   hackage2nix uses the latest version of a package unless an explicit
+#   constraint is configured, running this script indirectly updates packages
+#   (when hackage2nix is executed afterwards).
+#
+#   Prints a version difference to stdout if the pin has been updated, nothing
+#   otherwise.
+#
+# EXIT STATUS
+#
+#   Always exit with zero (even if nothing changed) unless there was an error.
 
 set -euo pipefail
 
+if [[ "${1:-}" == "--do-commit" ]]; then
+  echo "$0: --do-commit is no longer supported. Use update-package-set.sh instead."
+  exit 100
+fi
+
 pin_file=pkgs/data/misc/hackage/pin.json
 current_commit="$(jq -r .commit $pin_file)"
 old_date="$(jq -r .msg $pin_file | sed 's/Update from Hackage at //')"
@@ -14,6 +38,7 @@ commit_msg="$(echo "$git_info" | jq -r .commit.commit.message)"
 new_date="$(echo "$commit_msg" | sed 's/Update from Hackage at //')"
 
 if [ "$current_commit" != "$head_commit" ]; then
+   echo "Updating all-cabal-hashes from $old_date to $new_date" >&2
    url="https://github.com/commercialhaskell/all-cabal-hashes/archive/$head_commit.tar.gz"
    hash="$(nix-prefetch-url "$url")"
    jq -n \
@@ -23,13 +48,9 @@ if [ "$current_commit" != "$head_commit" ]; then
      --arg commit_msg "$commit_msg" \
      '{commit: $commit, url: $url, sha256: $hash, msg: $commit_msg}' \
      > $pin_file
+else
+   echo "No new all-cabal-hashes version" >&2
+   exit 0
 fi
 
-if [[ "${1:-}" == "--do-commit" ]]; then
-git add pkgs/data/misc/hackage/pin.json
-git commit -F - << EOF
-all-cabal-hashes: $old_date -> $new_date
-
-This commit has been generated by maintainers/scripts/haskell/update-hackage.sh
-EOF
-fi
+echo "$old_date -> $new_date"

maintainers/scripts/haskell/update-package-set.sh

@@ -0,0 +1,53 @@
+#! /usr/bin/env nix-shell
+#! nix-shell -i bash
+#! nix-shell -p git -I nixpkgs=.
+set -euo pipefail
+
+filesToStage=(
+  'pkgs/data/misc/hackage/pin.json'
+  'pkgs/development/haskell-modules/configuration-hackage2nix/stackage.yaml'
+  'pkgs/development/haskell-modules/hackage-packages.nix'
+)
+
+if ! git diff --quiet --cached; then
+  echo "Please commit staged changes before running $0" >&2
+  exit 100
+fi
+
+if ! git diff --quiet -- "${filesToStage[@]}"; then
+  echo -n "Please commit your changes to the following files before running $0: " >&2
+  echo    "${filesToStage[@]}" >&2
+  exit 100
+fi
+
+stackage_diff="$(./maintainers/scripts/haskell/update-stackage.sh)"
+hackage_diff="$(./maintainers/scripts/haskell/update-hackage.sh)"
+readonly stackage_diff hackage_diff
+
+# Prefer Stackage version diff in the commit header, fall back to Hackage
+if [[ -n "$stackage_diff" ]]; then
+  commit_message="haskellPackages: stackage $stackage_diff"
+  if [[ -n "$hackage_diff" ]]; then
+    commit_message="$commit_message
+
+all-cabal-hashes: $hackage_diff"
+  fi
+elif [[ -n "$hackage_diff" ]]; then
+  commit_message="haskellPackages: hackage $hackage_diff
+
+all-cabal-hashes: $hackage_diff"
+else
+  echo "Neither Hackage nor Stackage changed. Nothing to do." >&2
+  exit 0
+fi
+
+commit_message="$commit_message
+
+(generated by maintainers/scripts/haskell/update-package-set.sh)"
+
+# Using fast here because after the hackage-update eval errors will likely break the transitive dependencies check.
+./maintainers/scripts/haskell/regenerate-hackage-packages.sh --fast
+
+# A --do-commit flag probably doesn't make much sense
+git add -- "${filesToStage[@]}"
+git commit -m "$commit_message"

maintainers/scripts/haskell/update-stackage.sh

@@ -1,9 +1,36 @@
 #! /usr/bin/env nix-shell
 #! nix-shell -i bash -p curl jq git gnused gnugrep -I nixpkgs=.
 # shellcheck shell=bash
+#
+# SYNOPSIS
+#
+#   Update version constraints in hackage2nix config file from Stackage.
+#
+# DESCRIPTION
+#
+#   Fetches the latest snapshot of the configured Stackage solver which is
+#   configured via the SOLVER (either LTS or Nightly) and VERSION variables in
+#   the script.
+#
+#   VERSION is only applicable if SOLVER is LTS. SOLVER=LTS and VERSION=22
+#   will cause update-stackage.sh to fetch the latest LTS-22.XX version.
+#   If empty, the latest version of the solver is used.
+#
+#   If the configuration file has been updated, update-stackage.sh prints a
+#   version difference to stdout, e.g. 23.11 -> 23.13. Otherwise, stdout remains
+#   empty.
+#
+# EXIT STATUS
+#
+#   Always exit with zero (even if nothing changed) unless there was an error.
 
 set -eu -o pipefail
 
+if [[ "${1:-}" == "--do-commit" ]]; then
+  echo "$0: --do-commit is no longer supported. Use update-package-set.sh instead."
+  exit 100
+fi
+
 # Stackage solver to use, LTS or Nightly
 # (should be capitalized like the display name)
 SOLVER=LTS
@@ -31,11 +58,11 @@ old_version=$(grep '^# Stackage' $stackage_config | sed -e 's/.\+ \([A-Za-z]\+ [
 version="$SOLVER $(sed -rn "s/^--.*http:..(www.)?stackage.org.snapshot.$(toLower "$SOLVER")-//p" "$tmpfile")"
 
 if [[ "$old_version" == "$version" ]]; then
-   echo "No new stackage version"
+   echo "No new stackage version" >&2
    exit 0 # Nothing to do
 fi
 
-echo "Updating Stackage from $old_version to $version."
+echo "Updating Stackage from $old_version to $version." >&2
 
 # Create a simple yaml version of the file.
 sed -r \
@@ -78,11 +105,4 @@ sed -r \
 # ShellCheck: latest version of command-line dev tool.
 # Agda: The Agda community is fast-moving; we strive to always include the newest versions of Agda and the Agda packages in nixpkgs.
 
-if [[ "${1:-}" == "--do-commit" ]]; then
-git add $stackage_config
-git commit -F - << EOF
-haskellPackages: stackage $old_version -> $version
-
-This commit has been generated by maintainers/scripts/haskell/update-stackage.sh
-EOF
-fi
+echo "$old_version -> $version"

pkgs/build-support/agda/default.nix

@@ -90,8 +90,6 @@ let
       pname,
       meta,
       buildInputs ? [ ],
-      everythingFile ? "./Everything.agda",
-      includePaths ? [ ],
       libraryName ? pname,
       libraryFile ? "${libraryName}.agda-lib",
       buildPhase ? null,
@@ -100,26 +98,22 @@ let
       ...
     }:
     let
-      agdaWithArgs = withPackages (filter (p: p ? isAgdaDerivation) buildInputs);
-      includePathArgs = concatMapStrings (path: "-i" + path + " ") (
-        includePaths ++ [ (dirOf everythingFile) ]
-      );
+      agdaWithPkgs = withPackages (filter (p: p ? isAgdaDerivation) buildInputs);
     in
     {
       inherit libraryName libraryFile;
 
       isAgdaDerivation = true;
 
-      buildInputs = buildInputs ++ [ agdaWithArgs ];
+      buildInputs = buildInputs ++ [ agdaWithPkgs ];
 
       buildPhase =
         if buildPhase != null then
           buildPhase
         else
           ''
             runHook preBuild
-            agda ${includePathArgs} ${everythingFile}
-            rm ${everythingFile} ${lib.interfaceFile Agda.version everythingFile}
+            agda --build-library
             runHook postBuild
           '';
 

pkgs/build-support/agda/lib.nix

@@ -6,8 +6,8 @@
     * The resulting path may not be normalized.
     *
     * Examples:
-    * interfaceFile pkgs.agda.version "./Everything.agda" == "_build/2.6.4.3/agda/./Everything.agdai"
-    * interfaceFile pkgs.agda.version "src/Everything.lagda.tex" == "_build/2.6.4.3/agda/src/Everything.agdai"
+    * interfaceFile pkgs.agda.version "./Foo.agda" == "_build/AGDA_VERSION/agda/./Foo.agdai"
+    * interfaceFile pkgs.agda.version "src/Foo.lagda.tex" == "_build/AGDA_VERSION/agda/src/Foo.agdai"
   */
   interfaceFile =
     agdaVersion: agdaFile:

pkgs/data/misc/hackage/pin.json

@@ -1,6 +1,6 @@
 {
-  "commit": "0b40331fe9f6ba2ce9cf1b8afe0a04aa79d36878",
-  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/0b40331fe9f6ba2ce9cf1b8afe0a04aa79d36878.tar.gz",
-  "sha256": "03mjsvybfh8bq5v475pqqs5bs9xdb0pm2qrw9w892q0q0ir5b6na",
-  "msg": "Update from Hackage at 2025-06-01T18:10:16Z"
+  "commit": "e184dedb360769d6e8e041e711559185f39ab55c",
+  "url": "https://github.com/commercialhaskell/all-cabal-hashes/archive/e184dedb360769d6e8e041e711559185f39ab55c.tar.gz",
+  "sha256": "16qlwrw96lf52yvmmhfl948wpimbnqm9z87j27agcdmigf5icg1s",
+  "msg": "Update from Hackage at 2025-07-07T21:33:55Z"
 }