Remove dead GHCJS import + fix stale binDirectoryFor call

.github/scripts/rebase_local.sh

@@ -0,0 +1,58 @@
+#!/bin/bash
+
+set -eux
+
+upstream_repo=$1
+# of the form [<branch>:<rebase-target>], e.g.:
+#   BA:master B1:master B2:B1 B3:B2
+spec=$2
+
+{
+
+git remote add upstream "${upstream_repo}" || true
+git fetch upstream
+
+output_branches=()
+
+# sync master with upstream
+git checkout master
+git reset --hard upstream/master
+output_branches+=( "master" )
+
+# rebase each branch
+mkdir -p rebase
+for branch_spec in ${spec} ; do
+	branch=$(echo "${branch_spec}" | awk -F ':' '{ print $1 }')
+	rebase_target=$(echo "${branch_spec}" | awk -F ':' '{ print $2 }')
+	git checkout "${branch}"
+    common_ancestor=$(git merge-base "${branch}" "origin/${rebase_target}")
+	[ -e rebase/"${branch}" ] && exit 1
+    mkdir -p rebase/"${branch}"
+	(
+	cd rebase/"${branch}"
+	echo "${common_ancestor}" > BASE_COMMIT
+    git format-patch "${common_ancestor}".."${branch}"
+    )
+	if compgen -G rebase/"${branch}"/*.patch > /dev/null; then
+	  git reset --hard "${rebase_target}"
+      git am --3way rebase/"${branch}"/*.patch
+	fi
+	output_branches+=( "${branch}" )
+done
+unset branch_spec branch
+
+# cherry-pick on stable-master
+git checkout stable-master
+git reset --hard upstream/master
+for branch_spec in ${spec} ; do
+    branch=$(echo "${branch_spec}" | awk -F ':' '{ print $1 }')
+    if compgen -G "rebase/${branch}"/*.patch > /dev/null; then
+        git am --3way "rebase/${branch}"/*.patch
+    fi
+done
+output_branches+=( "stable-master" )
+
+} >&2
+
+echo "${output_branches[*]}"
+

.github/scripts/rebase_spec.sh

@@ -0,0 +1,167 @@
+#!/bin/bash
+
+# Branch regex we consider for rebase targets.
+# For our purposes this is usually 'stable-haskell/feature/*'.
+# 'master' is always considered.
+branch_regex=$1
+shift 1
+declare -a input_branches
+input_branches=( "$@" )
+set -eux
+
+[ ${#input_branches[@]} -eq 0 ] &&
+	input_branches=( $(gh pr list --label rebase --state open --json headRefName --jq ".[] | select( .headRefName | match(\"${branch_regex}\")) | .headRefName" --template '{{range .}}{{tablerow .headRefName}}{{end}}') )
+
+branch_list=( )
+declare -A branch_map
+
+# @FUNCTION: die
+# @USAGE: [msg]
+# @DESCRIPTION:
+# Exits the shell script with status code 2
+# and prints the given message in red to STDERR, if any.
+die() {
+    (>&2 red_message "$1")
+    exit 2
+}
+
+# @FUNCTION: red_message
+# @USAGE: <msg>
+# @DESCRIPTION:
+# Print a red message.
+red_message() {
+    printf "\\033[0;31m%s\\033[0m\\n" "$1"
+}
+
+# @FUNCTION: array_contains
+# @USAGE: <arr_ref> <val>
+# @DESCRIPTION:
+# Checks whether the array reference contains the given value.
+# @RETURN: 0 if value exists, 1 otherwise
+array_contains() {
+    local -n arr=$1
+    local val=$2
+    shift 2
+    if [[ " ${arr[*]} " =~ [[:space:]]${val}[[:space:]] ]]; then
+        return 0
+    else
+        return 1
+    fi
+}
+
+max_backtrack=10
+
+# @FUNCTION: backtrack
+# @USAGE: <map_ref> <start_key> <abort_value>
+# @DESCRIPTION:
+# Backtrack dependencies through an array list.
+# E.g. given an associated array with key value pairs of:
+#   B1 -> M
+#   B2 -> B1
+#   B3 -> B2
+#
+# ...if we pass B3 as start_key and M as abort_value, then
+# we receive the flattened ordered list "B1 B2 B3"
+# @STDOUT: space separated list of backtracked values
+backtrack() {
+    backtrack_ 0 "$1" "$2" "$3"
+}
+
+# internal to track backtrack depth
+backtrack_() {
+    local depth=$1
+    if [[ $depth -gt $max_backtrack ]] ; then
+        die "Dependency backtracking too deep... aborting!"
+    fi
+    shift 1
+
+    if [[ $1 != map ]] ; then
+      local -n map=$1
+    fi
+
+    local base=$2
+    local abort_value=$3
+    local value
+
+    if [ "${base}" = "${abort_value}" ] ; then
+        return
+    fi
+
+    value=${map[$base]}
+
+    if [ "${value}" = "${abort_value}" ] ; then
+        if ! array_contains branch_list "${base}" ; then
+          echo "${base}"
+        fi
+    else
+        if array_contains branch_list "${base}" ; then
+          backtrack_ $((depth++)) map "${map[$value]}" "${abort_value}"
+        else
+          echo "$(backtrack_ $((depth++)) map "${map[$base]}" "${abort_value}")" "${base}"
+        fi
+    fi
+}
+
+create_branch_map() {
+    local -n arr=$1
+    local -n discovered=$2
+    local -n map=$3
+
+	while IFS= read -r branch || [[ -n $branch ]]; do
+    rebase_target=$(git branch --merged "${branch}" --sort="ahead-behind:${branch}" --format="%(refname:short)" | grep -e "${branch_regex}" -e '^master$' | awk 'NR==2{print;exit}')
+
+	# this is the case when the branch is actually behind master... we then
+	# still want to rebase against master
+	if [ -z "${rebase_target}" ] ; then
+		rebase_target=master
+	fi
+
+    if ! array_contains input_branches "${rebase_target}" && [ "${rebase_target}" != "master" ] ; then
+		discovered+=( "${rebase_target}" )
+	fi
+
+    map["${branch}"]="${rebase_target}"
+done < <(printf '%s\n' "${arr[@]}")
+}
+
+{
+
+# create branch rebase tree
+# we're doing that on the state of the local tree/master
+newly_detected_input_branches=( )
+create_branch_map input_branches newly_detected_input_branches branch_map
+# these shenanigns are needed in case the rebase target branches themselves do not have
+# the 'rebase' label... this would break cherry-picking on master, so we include "parent"
+# branches regardless
+while true ; do
+	if [ ${#newly_detected_input_branches[@]} -eq 0 ] ; then
+		break
+	else
+		nothing=( )
+		create_branch_map newly_detected_input_branches nothing branch_map
+		newly_detected_input_branches=( "${nothing[@]}" )
+	fi
+done
+
+} >&2
+
+# flatten recursively
+for key in "${!branch_map[@]}"; do
+    value=${branch_map[$key]}
+    if [ "${value}" = "master" ] ; then
+        if ! array_contains branch_list "${key}" ; then
+          branch_list+=( "${key}" )
+        fi
+    else
+        # shellcheck disable=SC2207
+        branch_list+=( $(backtrack branch_map "$key" "master") )
+    fi
+done
+unset key
+
+result=( )
+for key in "${branch_list[@]}"; do
+    result+=( "${key}:${branch_map[$key]}" )
+done
+echo "${result[@]}"
+

.github/scripts/test.bash → .github/scripts/test.sh

@@ -25,7 +25,7 @@ cabal update
 # TODO: we want to avoid building here... we should just
 # be using the previously built 'cabal-tests' binary
 # Also see https://github.com/haskell/cabal/issues/11048
-cabal run -w "ghc-${GHC_TEST_VERSION}" ${ADD_CABAL_ARGS} cabal-testsuite:cabal-tests -- \
+cabal run ${ADD_CABAL_ARGS} cabal-testsuite:cabal-tests -- \
   --with-cabal "$(pwd)/out/cabal" \
   --intree-cabal-lib "$(pwd)" \
   --test-tmp "$(pwd)/testdb" \

.github/workflows/rebase.yaml

@@ -0,0 +1,156 @@
+name: Rebase against upstream
+
+on:
+  schedule:
+    - cron: '0 0 * * *'
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  issues: write
+  pull-requests: read
+
+concurrency:
+  group: ${{ github.workflow }}
+  cancel-in-progress: false
+
+jobs:
+  rebase:
+    name: Rebase now!
+    runs-on: ubuntu-latest
+    env:
+      UPSTREAM_REPO: https://github.com/haskell/cabal.git
+      CI_BRANCH: stable-haskell/feature/rebase-CI
+    outputs:
+      rebase_output_json: ${{ steps.rebase.outputs.branches_json }}
+      rebase_output: ${{ steps.rebase.outputs.branches }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      - id: rebase
+        name: rebase
+        run: |
+          set -eux
+
+          git switch --detach
+          git fetch origin refs/heads/*:refs/heads/*
+
+          gh repo set-default stable-haskell/cabal
+          git config checkout.defaultRemote origin
+
+          # required to apply patches
+          git config user.email "ci@users.noreply.github.com"
+          git config user.name "GitHub CI"
+
+          # this does not push
+          branch_spec=$(bash .github/scripts/rebase_spec.sh '^stable-haskell/feature/.*')
+          rebased_branches=( $(bash .github/scripts/rebase_local.sh ${{ env.UPSTREAM_REPO }} "${branch_spec}") )
+
+          # we use branches_json to trigger release workflow, but we don't want to do it for upstream master
+          echo "branches_json=$(jq --compact-output --null-input '$ARGS.positional' --args -- "${rebased_branches[@]/#/tmp\/}" | jq --compact-output 'del(.[] | select(. == "tmp/master"))')" >> "$GITHUB_OUTPUT"
+          # this output is used to update remote branches, so it shall include upstream master
+          echo "branches=${rebased_branches[*]} master" >> "$GITHUB_OUTPUT"
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+      - name: save branches on remote
+        run: |
+          set -eux
+
+          for branch in ${{ steps.rebase.outputs.branches }} ; do
+              git checkout "${branch}"
+              git push -f https://${{ secrets.REBASE_PAT }}@github.com/${{ github.repository }}.git ${branch}:tmp/${branch}
+          done
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+      - if: always()
+        name: backup
+        run: |
+          git checkout -f master || true
+          git archive master > backup.tar
+          tar -rf backup.tar .git rebase
+
+      - if: always()
+        name: Upload artifact
+        uses: actions/upload-artifact@v4
+        with:
+          if-no-files-found: error
+          retention-days: 7
+          name: backup
+          path: |
+            ./backup.tar
+
+      - name: checkout reusable workflow
+        run: |
+          git checkout -f "${{ env.CI_BRANCH }}"
+
+  release-workflow:
+    needs: ["rebase"]
+    uses: ./.github/workflows/reusable-release.yml
+    with:
+      branches: ${{ needs.rebase.outputs.rebase_output_json }}
+      ghc: "9.6.7"
+      cabal: "3.12.1.0"
+
+  push-job:
+    runs-on: ubuntu-latest
+    needs: [rebase, release-workflow]
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          persist-credentials: false
+
+      - name: update branches
+        run: |
+          set -eux
+
+          for branch in ${{ needs.rebase.outputs.rebase_output }} ; do
+              git checkout "${branch}"
+              git push -f https://${{ secrets.REBASE_PAT }}@github.com/${{ github.repository }}.git tmp/${branch}:${branch}
+          done
+          git push -f https://${{ secrets.REBASE_PAT }}@github.com/${{ github.repository }}.git tmp/stable-master:stable-master
+
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+      - name: delete tmp branches
+        if: always()
+        run: |
+          unset branch
+          for branch in $(git for-each-ref --format="%(refname:short)" -- 'refs/heads/tmp') ; do
+            git push -f https://${{ secrets.REBASE_PAT }}@github.com/${{ github.repository }}.git :${branch}
+          done
+        shell: bash
+        env:
+          GH_TOKEN: ${{ github.token }}
+
+  notify-job:
+    runs-on: ubuntu-latest
+    needs: [release-workflow]
+    if: ${{ always() && contains(needs.*.result, 'failure') }}
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      # create an issue with a link to the workflow run on failure
+      # TODO: don't create more issues, only use one
+      - run: |
+          set -eux
+          gh repo set-default stable-haskell/cabal
+          for issue in $(gh issue list --label rebase-failure --json url -q '.[] | .url') ; do
+            gh issue close "${issue}"
+          done
+          gh issue create --title "Rebase failed on $(date -u +"%Y-%m-%d")" --label rebase-failure --body "${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+        env:
+          GH_TOKEN: ${{ github.token }}
+