Test on JFS, fixes #792

.cirrus.yml

@@ -1,5 +1,5 @@
 freebsd_instance:
-  image_family: freebsd-13-2
+  image_family: freebsd-13-1
 
 build_task:
   name: build
@@ -16,9 +16,7 @@ build_task:
     AWS_ACCESS_KEY_ID: ENCRYPTED[6ed6287e2dd78ab5f84b22232c5245834ab042bd8ba443883aaf4b4d1ecc0481add1fdfad5ae6f6a8cfb418e6f19b2fc]
     AWS_SECRET_ACCESS_KEY: ENCRYPTED[16f3cda2954c7cee99444e6788eb5997382aa4ce1477e7523fef2586077541f43b5c816156961fc6b4677259679875a7]
     S3_HOST: ENCRYPTED[ce961780a33159f7d1d8046956b5ac6ebc3bfc8149428e5f538576cda51d9f3d0c35b79cdd1e325793639ff6e31f889d]
-  install_script:
+  install_script: pkg install -y ghc hs-cabal-install git bash misc/compat10x misc/compat11x misc/compat12x gmake llvm14
-    - sed -i.bak -e 's/quarterly/latest/' /etc/pkg/FreeBSD.conf
-    - pkg install -y ghc hs-cabal-install git bash misc/compat10x misc/compat11x misc/compat12x gmake llvm14
   script:
     - tzsetup Etc/GMT
     - adjkerntz -a

.github/scripts/cabal-cache.sh

@@ -1,13 +0,0 @@
-#!/usr/bin/env bash
-
-case "$(uname -s)" in
-	MSYS_*|MINGW*)
-		ext=".exe"
-		;;
-	*)
-		ext=""
-	   ;;
-esac
-
-echo "cabal-cache disabled (CABAL_CACHE_DISABLE set)"
-

.github/scripts/common.sh

@@ -15,7 +15,7 @@ sync_from() {
 		cabal_store_path="$(dirname "$(cabal help user-config | tail -n 1 | xargs)")/store"
 	fi
 
-	cabal-cache.sh sync-from-archive \
+	cabal-cache sync-from-archive \
 		--host-name-override=${S3_HOST} \
 		--host-port-override=443 \
 		--host-ssl-override=True \
@@ -29,7 +29,7 @@ sync_to() {
 		cabal_store_path="$(dirname "$(cabal help user-config | tail -n 1 | xargs)")/store"
 	fi
 
-	cabal-cache.sh sync-to-archive \
+	cabal-cache sync-to-archive \
 		--host-name-override=${S3_HOST} \
 		--host-port-override=443 \
 		--host-ssl-override=True \
@@ -115,10 +115,6 @@ download_cabal_cache() {
 		mv "cabal-cache${exe}" "${dest}${exe}"
 		chmod +x "${dest}${exe}"
 	fi
-
-	# install shell wrapper
-	cp "${CI_PROJECT_DIR}"/.github/scripts/cabal-cache.sh "$HOME"/.local/bin/
-	chmod +x "$HOME"/.local/bin/cabal-cache.sh
     )
 }
 

.github/scripts/cross.sh

@@ -1,74 +0,0 @@
-#!/usr/bin/env bash
-
-set -ex
-
-. .github/scripts/common.sh
-
-run() {
-    "$@"
-}
-
-if [ "${OS}" = "Windows" ] ; then
-	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/ghcup
-else
-	GHCUP_DIR="${GHCUP_INSTALL_BASE_PREFIX}"/.ghcup
-fi
-
-git_describe
-
-rm -rf "${GHCUP_DIR}"
-mkdir -p "${GHCUP_BIN}"
-
-cp "out/${ARTIFACT}"-* "$GHCUP_BIN/ghcup${ext}"
-cp "out/test-${ARTIFACT}"-* "ghcup-test${ext}"
-chmod +x "$GHCUP_BIN/ghcup${ext}"
-chmod +x "ghcup-test${ext}"
-
-"$GHCUP_BIN/ghcup${ext}" --version
-eghcup --version
-sha_sum "$GHCUP_BIN/ghcup${ext}"
-sha_sum "$(raw_eghcup --offline whereis ghcup)"
-
-
-### cross build
-
-eghcup --numeric-version
-
-eghcup install ghc "${GHC_VER}"
-eghcup set ghc "${GHC_VER}"
-eghcup install cabal "${CABAL_VER}"
-
-cabal --version
-
-eghcup debug-info
-
-ecabal update
-
-"${WRAPPER}" "$GHCUP_BIN/ghcup${ext}" -c -s "file://$CI_PROJECT_DIR/data/metadata/ghcup-${JSON_VERSION}.yaml" -v \
-	compile ghc \
-	$(if [ -n "${HADRIAN_FLAVOUR}" ] ; then printf "%s" "--flavour=${HADRIAN_FLAVOUR}" ; else true ; fi) \
-	-j "$(nproc)" \
-	-v "${GHC_TARGET_VERSION}" \
-	-b "${GHC_VER}" \
-	-x "${CROSS}" \
-	-- ${BUILD_CONF_ARGS}
-eghcup set ghc "${CROSS}-${GHC_TARGET_VERSION}"
-
-[ "$($(eghcup whereis ghc "${CROSS}-${GHC_TARGET_VERSION}") --numeric-version)" = "${GHC_TARGET_VERSION}" ]
-
-# test that doing fishy symlinks into GHCup dir doesn't cause weird stuff on 'ghcup nuke'
-mkdir no_nuke/
-mkdir no_nuke/bar
-echo 'foo' > no_nuke/file
-echo 'bar' > no_nuke/bar/file
-ln -s "$CI_PROJECT_DIR"/no_nuke/ "${GHCUP_DIR}"/cache/no_nuke
-ln -s "$CI_PROJECT_DIR"/no_nuke/ "${GHCUP_DIR}"/logs/no_nuke
-
-# nuke
-eghcup nuke
-[ ! -e "${GHCUP_DIR}" ]
-
-# make sure nuke doesn't resolve symlinks
-[ -e "$CI_PROJECT_DIR"/no_nuke/file ]
-[ -e "$CI_PROJECT_DIR"/no_nuke/bar/file ]
-

.github/workflows/bootstrap.yaml

@@ -25,7 +25,7 @@ jobs:
         include:
           - os: ubuntu-latest
             DISTRO: Ubuntu
-          - os: macOS-11
+          - os: macOS-10.15
             DISTRO: na
           - os: windows-latest
             DISTRO: na
@@ -56,3 +56,51 @@ jobs:
           Write-Host "Current Working Directory: $curDir"
           ./scripts/bootstrap/bootstrap-haskell.ps1 -InstallDir ${GITHUB_WORKSPACE} -BootstrapUrl ("{0}/scripts/bootstrap/bootstrap-haskell" -f $curDir) -InBash
         shell: pwsh
+
+  jfs:
+    name: jfs
+    runs-on: [self-hosted, Linux, ARM64, JFS]
+    defaults:
+      run:
+        working-directory: /mnt/jfs
+    env:
+      BOOTSTRAP_HASKELL_CABAL_VERSION: 3.6.2.0
+      BOOTSTRAP_HASKELL_GHC_VERSION: 8.10.7
+      BOOTSTRAP_HASKELL_NONINTERACTIVE: yes
+      GHCUP_INSTALL_BASE_PREFIX: "/mnt/jfs"
+    steps:
+      - uses: docker://hasufell/arm64v8-ubuntu-haskell:focal
+        name: Cleanup
+        with:
+          args: "find . -mindepth 1 -maxdepth 1 -exec rm -rf -- {} +"
+
+      - name: Checkout code
+        uses: actions/checkout@v3
+
+      - uses: docker://hasufell/arm64v8-ubuntu-haskell:focal
+        name: Run build (arm64v8 linux)
+        with:
+          args: sh ./.github/scripts/bootstrap.sh
+        env:
+          BOOTSTRAP_HASKELL_CABAL_VERSION: ${{ env.BOOTSTRAP_HASKELL_CABAL_VERSION }}
+          BOOTSTRAP_HASKELL_GHC_VERSION: ${{ env.BOOTSTRAP_HASKELL_GHC_VERSION }}
+          BOOTSTRAP_HASKELL_NONINTERACTIVE: ${{ env.BOOTSTRAP_HASKELL_NONINTERACTIVE }}
+          GHCUP_INSTALL_BASE_PREFIX: ${{ env.GHCUP_INSTALL_BASE_PREFIX }}
+
+  some:
+    name: some
+    runs-on: ubuntu-20.04
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v3
+        with:
+          submodules: 'true'
+
+      - name: Test ghcup bug
+        run: |
+          ls -lah /usr/local/.ghcup/cache
+          ghcup --version
+          ghcup --verbose list
+
+
+

.github/workflows/cross.yaml

@@ -1,140 +0,0 @@
-name: Test cross bindists
-
-on:
-  push:
-    branches:
-      - master
-    tags:
-      - 'v*'
-  pull_request:
-    branches:
-      - master
-  schedule:
-    - cron: '0 2 * * *'
-
-env:
-  CABAL_CACHE_DISABLE: ${{ vars.CABAL_CACHE_DISABLE }}
-  CABAL_CACHE_NONFATAL: yes
-
-jobs:
-  build:
-    name: Build linux binary
-    runs-on: ubuntu-latest
-    env:
-      CABAL_VER: 3.10.1.0
-      JSON_VERSION: "0.0.7"
-      AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
-      AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
-      S3_HOST: ${{ secrets.S3_HOST }}
-      ARTIFACT: "x86_64-linux-ghcup"
-      GHC_VER: 8.10.7
-      ARCH: 64
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          submodules: 'true'
-
-      - name: Run build
-        uses: docker://hasufell/alpine-haskell:3.12
-        with:
-          args: sh .github/scripts/build.sh
-        env:
-          ARTIFACT: ${{ env.ARTIFACT }}
-          ARCH: ${{ env.ARCH }}
-          GHC_VER: ${{ env.GHC_VER }}
-          DISTRO: Alpine
-          AWS_SECRET_ACCESS_KEY: ${{ env.AWS_SECRET_ACCESS_KEY }}
-          AWS_ACCESS_KEY_ID: ${{ env.AWS_ACCESS_KEY_ID }}
-          S3_HOST: ${{ env.S3_HOST }}
-
-      - if: always()
-        name: Upload artifact
-        uses: actions/upload-artifact@v3
-        with:
-          name: artifacts
-          path: |
-            ./out/*
-
-  test-cross-linux:
-    name: Test linux cross
-    needs: "build"
-    runs-on: [self-hosted, Linux, X64]
-    container:
-      image: registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10:8d0224e6b2a08157649651e69302380b2bd24e11
-      options: --user root
-      env:
-        CABAL_VER: 3.6.2.0
-        BUILD_CONF_ARGS: "--enable-unregisterised"
-        HADRIAN_FLAVOUR: ""
-        JSON_VERSION: "0.0.7"
-        GHC_VER: 8.10.6
-        GHC_TARGET_VERSION: "8.10.7"
-        ARCH: 64
-        DISTRO: Debian
-        ARTIFACT: "x86_64-linux-ghcup"
-        CROSS: "arm-linux-gnueabihf"
-        WRAPPER: "run"
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          submodules: 'true'
-
-      - uses: actions/download-artifact@v3
-        with:
-          name: artifacts
-          path: ./out
-
-      - name: Run test (64 bit linux)
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https gcc autoconf automake build-essential curl gzip
-          sudo apt-get install -y gcc-arm-linux-gnueabihf
-          sudo dpkg --add-architecture armhf
-          sudo apt-get update -y
-          sudo apt-get install -y libncurses-dev:armhf
-          sh .github/scripts/cross.sh
-
-  test-cross-js:
-    name: Test GHC JS cross
-    needs: "build"
-    runs-on: [self-hosted, Linux, X64]
-    container:
-      image: registry.gitlab.haskell.org/ghc/ci-images/x86_64-linux-deb10:8d0224e6b2a08157649651e69302380b2bd24e11
-      options: --user root
-      env:
-        CABAL_VER: 3.6.2.0
-        BUILD_CONF_ARGS: ""
-        HADRIAN_FLAVOUR: "default+native_bignum"
-        JSON_VERSION: "0.0.7"
-        GHC_VER: 9.6.2
-        GHC_TARGET_VERSION: "9.6.2"
-        ARCH: 64
-        DISTRO: Debian
-        ARTIFACT: "x86_64-linux-ghcup"
-        CROSS: "javascript-unknown-ghcjs"
-        WRAPPER: "emconfigure"
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v3
-        with:
-          submodules: 'true'
-
-      - uses: actions/download-artifact@v3
-        with:
-          name: artifacts
-          path: ./out
-
-      - name: Run test (64 bit linux)
-        run: |
-          sudo apt-get update -y
-          sudo apt-get install -y libnuma-dev zlib1g-dev libgmp-dev libgmp10 libssl-dev liblzma-dev libbz2-dev git wget lsb-release software-properties-common gnupg2 apt-transport-https gcc autoconf automake build-essential curl gzip
-          git clone https://github.com/emscripten-core/emsdk.git
-          cd emsdk
-          ./emsdk install latest
-          ./emsdk activate latest
-          . ./emsdk_env.sh
-          cd ..
-          bash .github/scripts/cross.sh
-

.github/workflows/docker.yaml

@@ -53,7 +53,7 @@ jobs:
           platforms: linux/amd64
 
   docker-arm32:
-    runs-on: [self-hosted, Linux, ARM64]
+    runs-on: [self-hosted, Linux, ARM64, aarch32-linux]
     steps:
       - uses: docker://arm64v8/ubuntu:focal
         name: Cleanup (aarch64 linux)
@@ -85,7 +85,7 @@ jobs:
         with:
           context: ./docker/arm32v7/focal
           push: true
-          tags: hasufell/arm32v7-ubuntu-haskell:focal
+          tags: hasufell/arm32v7-debian-haskell:10
           platforms: linux/arm
 
   docker-aarch:
@@ -121,5 +121,5 @@ jobs:
         with:
           context: ./docker/arm64v8/focal
           push: true
-          tags: hasufell/arm64v8-ubuntu-haskell:focal
+          tags: hasufell/arm64v8-debian-haskell:10
           platforms: linux/arm64

.github/workflows/release.yaml

@@ -12,16 +12,12 @@ on:
   schedule:
     - cron: '0 2 * * *'
 
-env:
-  CABAL_CACHE_DISABLE: ${{ vars.CABAL_CACHE_DISABLE }}
-  CABAL_CACHE_NONFATAL: yes
-
 jobs:
   build-linux:
     name: Build linux binary
     runs-on: ${{ matrix.os }}
     env:
-      CABAL_VER: 3.10.1.0
+      CABAL_VER: 3.8.1.0
       JSON_VERSION: "0.0.7"
       AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
       AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
@@ -85,7 +81,7 @@ jobs:
     name: Build ARM binary
     runs-on: ${{ matrix.os }}
     env:
-      CABAL_VER: 3.10.1.0
+      CABAL_VER: 3.8.1.0
       JSON_VERSION: "0.0.7"
       AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
       AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }}
@@ -94,7 +90,7 @@ jobs:
       fail-fast: true
       matrix:
         include:
-          - os: [self-hosted, Linux, ARM64]
+          - os: [self-hosted, Linux, ARM64, aarch32-linux]
             ARTIFACT: "armv7-linux-ghcup"
             GHC_VER: 9.2.2
             ARCH: ARM
@@ -158,7 +154,7 @@ jobs:
     name: Build binary (Mac/Win)
     runs-on: ${{ matrix.os }}
     env:
-      CABAL_VER: 3.10.1.0
+      CABAL_VER: 3.8.1.0
       MACOSX_DEPLOYMENT_TARGET: 10.13
       JSON_VERSION: "0.0.7"
       AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
@@ -172,7 +168,7 @@ jobs:
             ARTIFACT: "aarch64-apple-darwin-ghcup"
             GHC_VER: 9.2.6
             ARCH: ARM64
-          - os: macOS-11
+          - os: macOS-10.15
             ARTIFACT: "x86_64-apple-darwin-ghcup"
             GHC_VER: 9.2.6
             ARCH: 64
@@ -251,7 +247,7 @@ jobs:
     needs: "build-linux"
     runs-on: ${{ matrix.os }}
     env:
-      CABAL_VER: 3.10.1.0
+      CABAL_VER: 3.8.1.0
       JSON_VERSION: "0.0.7"
     strategy:
       matrix:
@@ -329,12 +325,12 @@ jobs:
     needs: "build-arm"
     runs-on: ${{ matrix.os }}
     env:
-      CABAL_VER: 3.10.1.0
+      CABAL_VER: 3.8.1.0
       JSON_VERSION: "0.0.7"
     strategy:
       matrix:
         include:
-          - os: [self-hosted, Linux, ARM64]
+          - os: [self-hosted, Linux, ARM64, aarch32-linux]
             ARTIFACT: "armv7-linux-ghcup"
             GHC_VER: 9.2.2
             ARCH: ARM
@@ -396,7 +392,7 @@ jobs:
     needs: "build-macwin"
     runs-on: ${{ matrix.os }}
     env:
-      CABAL_VER: 3.10.1.0
+      CABAL_VER: 3.8.1.0
       MACOSX_DEPLOYMENT_TARGET: 10.13
       JSON_VERSION: "0.0.7"
     strategy:
@@ -407,7 +403,7 @@ jobs:
             GHC_VER: 9.2.6
             ARCH: ARM64
             DISTRO: na
-          - os: macOS-11
+          - os: macOS-10.15
             ARTIFACT: "x86_64-apple-darwin-ghcup"
             GHC_VER: 9.2.6
             ARCH: 64

CHANGELOG.md

@@ -1,18 +1,5 @@
 # Revision history for ghcup
 
-## 0.1.19.5 -- ????-?-??
-
-* support JS cross compilers wrt [#838](https://github.com/haskell/ghcup-hs/issues/838)
-
-## 0.1.19.4 -- 2023-7-02
-
-* fix missing TUI for aarch64 linux binaries
-
-## 0.1.19.3 -- 2023-6-29
-
-* Implement support for nightlies, wrt [#824](https://github.com/haskell/ghcup-hs/issues/824)
-* Fix GC with XDG dirs, fixes [#810](https://github.com/haskell/ghcup-hs/issues/810)
-
 ## 0.1.19.2 -- 2023-2-24
 
 * Follow-up fix for JFS/ReiserFS and other filesystem that don't support `d_type`, fixes [#787](https://github.com/haskell/ghcup-hs/issues/787)

app/ghcup/BrickMain.hs

@@ -73,8 +73,8 @@ data BrickData = BrickData
   deriving Show
 
 data BrickSettings = BrickSettings
-  { showAllVersions    :: Bool
+  { showAllVersions :: Bool
-  , showAllTools       :: Bool
+  , showAllTools    :: Bool
   }
   deriving Show
 
@@ -156,10 +156,10 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
       <+> padLeft (Pad 1) (minHSize 25 $ str "Tags")
       <+> padLeft (Pad 5) (str "Notes")
   renderList' bis@BrickInternalState{..} =
-    let minTagSize = V.maximum $ V.map (length . intercalate "," . fmap tagToString . lTag) clr
+    let getMinLength = length . intercalate "," . fmap tagToString
-        minVerSize = V.maximum $ V.map (\ListResult{..} -> T.length $ tVerToText (GHCTargetVersion lCross lVer)) clr
+        minLength = V.maximum $ V.map (getMinLength . lTag) clr
-    in withDefAttr listAttr . drawListElements (renderItem minTagSize minVerSize) True $ bis
+    in withDefAttr listAttr . drawListElements (renderItem minLength) True $ bis
-  renderItem minTagSize minVerSize _ b listResult@ListResult{lTag = lTag', ..} =
+  renderItem minTagSize _ b listResult@ListResult{lTag = lTag', ..} =
     let marks = if
           | lSet       -> (withAttr (attrName "set") $ str "✔✔")
           | lInstalled -> (withAttr (attrName "installed") $ str "✓ ")
@@ -184,7 +184,7 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
                ( minHSize 6
                  (printTool lTool)
                )
-          <+> minHSize minVerSize (str ver)
+          <+> minHSize 15 (str ver)
           <+> (let l = catMaybes . fmap printTag $ sort lTag'
                in  padLeft (Pad 1) $ minHSize minTagSize $ if null l
                      then emptyWidget
@@ -202,11 +202,9 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
   printTag Recommended    = Just $ withAttr (attrName "recommended") $ str "recommended"
   printTag Latest         = Just $ withAttr (attrName "latest") $ str "latest"
   printTag Prerelease     = Just $ withAttr (attrName "prerelease") $ str "prerelease"
-  printTag Nightly        = Just $ withAttr (attrName "nightly") $ str "nightly"
   printTag (Base pvp'')   = Just $ str ("base-" ++ T.unpack (prettyPVP pvp''))
   printTag Old            = Nothing
   printTag LatestPrerelease = Just $ withAttr (attrName "latest-prerelease") $ str "latest-prerelease"
-  printTag LatestNightly    = Just $ withAttr (attrName "latest-nightly") $ str "latest-nightly"
   printTag (UnknownTag t) = Just $ str t
 
   printTool Cabal = str "cabal"
@@ -218,10 +216,8 @@ ui dimAttrs BrickState{ appSettings = as@BrickSettings{}, ..}
   printNotes ListResult {..} =
     (if hlsPowered then [withAttr (attrName "hls-powered") $ str "hls-powered"] else mempty
       )
+      ++ (if fromSrc then [withAttr (attrName "compiled") $ str "compiled"] else mempty)
       ++ (if lStray then [withAttr (attrName "stray") $ str "stray"] else mempty)
-      ++ (case lReleaseDay of
-            Nothing -> mempty
-            Just d  -> [withAttr (attrName "day") $ str (show d)])
 
   -- | Draws the list elements.
   --
@@ -276,22 +272,19 @@ app attrs dimAttrs =
 defaultAttributes :: Bool -> AttrMap
 defaultAttributes no_color = attrMap
   Vty.defAttr
-  [ (attrName "active"            , Vty.defAttr `withBackColor` Vty.blue)
+  [ (attrName "active"       , Vty.defAttr `withBackColor` Vty.blue)
-  , (attrName "not-installed"     , Vty.defAttr `withForeColor` Vty.red)
+  , (attrName "not-installed", Vty.defAttr `withForeColor` Vty.red)
-  , (attrName "set"               , Vty.defAttr `withForeColor` Vty.green)
+  , (attrName "set"          , Vty.defAttr `withForeColor` Vty.green)
-  , (attrName "installed"         , Vty.defAttr `withForeColor` Vty.green)
+  , (attrName "installed"    , Vty.defAttr `withForeColor` Vty.green)
-  , (attrName "recommended"       , Vty.defAttr `withForeColor` Vty.green)
+  , (attrName "recommended"  , Vty.defAttr `withForeColor` Vty.green)
-  , (attrName "hls-powered"       , Vty.defAttr `withForeColor` Vty.green)
+  , (attrName "hls-powered"  , Vty.defAttr `withForeColor` Vty.green)
-  , (attrName "latest"            , Vty.defAttr `withForeColor` Vty.yellow)
+  , (attrName "latest"       , Vty.defAttr `withForeColor` Vty.yellow)
   , (attrName "latest-prerelease" , Vty.defAttr `withForeColor` Vty.red)
-  , (attrName "latest-nightly"    , Vty.defAttr `withForeColor` Vty.red)
+  , (attrName "prerelease"   , Vty.defAttr `withForeColor` Vty.red)
-  , (attrName "prerelease"        , Vty.defAttr `withForeColor` Vty.red)
+  , (attrName "compiled"     , Vty.defAttr `withForeColor` Vty.blue)
-  , (attrName "nightly"           , Vty.defAttr `withForeColor` Vty.red)
+  , (attrName "stray"        , Vty.defAttr `withForeColor` Vty.blue)
-  , (attrName "compiled"          , Vty.defAttr `withForeColor` Vty.blue)
+  , (attrName "help"         , Vty.defAttr `withStyle`     Vty.italic)
-  , (attrName "stray"             , Vty.defAttr `withForeColor` Vty.blue)
+  , (attrName "hooray"       , Vty.defAttr `withForeColor` Vty.brightWhite)
-  , (attrName "day"               , Vty.defAttr `withForeColor` Vty.blue)
-  , (attrName "help"              , Vty.defAttr `withStyle`     Vty.italic)
-  , (attrName "hooray"            , Vty.defAttr `withForeColor` Vty.brightWhite)
   ]
   where
     withForeColor | no_color  = const
@@ -418,17 +411,13 @@ filterVisible :: Bool -> Bool -> ListResult -> Bool
 filterVisible v t e | lInstalled e = True
                     | v
                     , not t
-                    , Nightly `notElem` lTag e
                     , lTool e `notElem` hiddenTools = True
                     | not v
                     , t
-                    , Old `notElem` lTag e
+                    , Old `notElem` lTag e = True
-                    , Nightly `notElem` lTag e = True
                     | v
-                    , Nightly `notElem` lTag e
                     , t = True
-                    | otherwise = (Old `notElem` lTag e)       &&
+                    | otherwise = (Old `notElem` lTag e) &&
-                                  (Nightly `notElem` lTag e)   &&
                                   (lTool e `notElem` hiddenTools)
 
 
@@ -471,19 +460,19 @@ install' _ (_, ListResult {..}) = do
       dirs <- lift getDirs
       case lTool of
         GHC   -> do
-          let vi = getVersionInfo (GHCTargetVersion lCross lVer) GHC dls
+          let vi = getVersionInfo lVer GHC dls
-          liftE $ installGHCBin (GHCTargetVersion lCross lVer) GHCupInternal False [] $> (vi, dirs, ce)
+          liftE $ installGHCBin lVer GHCupInternal False [] $> (vi, dirs, ce)
         Cabal -> do
-          let vi = getVersionInfo (GHCTargetVersion lCross lVer) Cabal dls
+          let vi = getVersionInfo lVer Cabal dls
           liftE $ installCabalBin lVer GHCupInternal False $> (vi, dirs, ce)
         GHCup -> do
           let vi = snd <$> getLatest dls GHCup
           liftE $ upgradeGHCup Nothing False False $> (vi, dirs, ce)
         HLS   -> do
-          let vi = getVersionInfo (GHCTargetVersion lCross lVer) HLS dls
+          let vi = getVersionInfo lVer HLS dls
           liftE $ installHLSBin lVer GHCupInternal False $> (vi, dirs, ce)
         Stack -> do
-          let vi = getVersionInfo (GHCTargetVersion lCross lVer) Stack dls
+          let vi = getVersionInfo lVer Stack dls
           liftE $ installStackBin lVer GHCupInternal False $> (vi, dirs, ce)
     )
     >>= \case
@@ -564,7 +553,7 @@ del' _ (_, ListResult {..}) = do
   let run = runE @'[NotInstalled, UninstallFailed]
 
   run (do
-      let vi = getVersionInfo (GHCTargetVersion lCross lVer) lTool dls
+      let vi = getVersionInfo lVer lTool dls
       case lTool of
         GHC   -> liftE $ rmGHCVer (GHCTargetVersion lCross lVer) $> vi
         Cabal -> liftE $ rmCabalVer lVer $> vi
@@ -574,7 +563,7 @@ del' _ (_, ListResult {..}) = do
     )
     >>= \case
           VRight vi -> do
-            when (lTool == GHC) $ logGHCPostRm (mkTVer lVer)
+            logGHCPostRm (mkTVer lVer)
             forM_ (_viPostRemove =<< vi) $ \msg ->
               logInfo msg
             pure $ Right ()
@@ -587,7 +576,7 @@ changelog' :: (MonadReader AppState m, MonadIO m)
            -> m (Either String ())
 changelog' _ (_, ListResult {..}) = do
   AppState { pfreq, ghcupInfo = GHCupInfo { _ghcupDownloads = dls }} <- ask
-  case getChangeLog dls lTool (ToolVersion lVer) of
+  case getChangeLog dls lTool (Left lVer) of
     Nothing -> pure $ Left $
       "Could not find ChangeLog for " <> prettyShow lTool <> ", version " <> T.unpack (prettyVer lVer)
     Just uri -> do
@@ -667,5 +656,5 @@ getAppData mgi = runExceptT $ do
   settings <- liftIO $ readIORef settings'
 
   flip runReaderT settings $ do
-    lV <- listVersions Nothing [] False True (Nothing, Nothing)
+    lV <- listVersions Nothing Nothing
     pure $ BrickData (reverse lV)

app/ghcup/GHCup/OptParse.hs

@@ -244,8 +244,7 @@ com =
       <> command
            "list"
            (info (List <$> listOpts <**> helper)
-                 (progDesc "Show available GHCs and other tools"
+                 (progDesc "Show available GHCs and other tools")
-                 <> footerDoc (Just $ text listToolFooter))
            )
       <> command
            "upgrade"

app/ghcup/GHCup/OptParse/ChangeLog.hs

@@ -35,6 +35,7 @@ import qualified Data.Text                     as T
 import Control.Exception.Safe (MonadMask)
 import GHCup.Types.Optics
 import GHCup.Utils
+import Data.Versions
 import URI.ByteString (serializeURIRef')
 import Data.Char (toLower)
 
@@ -80,7 +81,7 @@ changelogP =
               <> completer toolCompleter
             )
           )
-    <*> optional (toolVersionTagArgument [] Nothing)
+    <*> optional (toolVersionTagArgument Nothing Nothing)
 
 
 
@@ -114,15 +115,20 @@ changelog :: ( Monad m
 changelog ChangeLogOptions{..} runAppState runLogger = do
   GHCupInfo { _ghcupDownloads = dls } <- runAppState getGHCupInfo
   let tool = fromMaybe GHC clTool
-      ver' = fromMaybe
+      ver' = maybe
-        (ToolTag Latest)
+        (Right Latest)
+        (\case
+          GHCVersion tv  -> Left (_tvVersion tv)
+          ToolVersion tv -> Left tv
+          ToolTag     t  -> Right t
+        )
         clToolVer
       muri = getChangeLog dls tool ver'
   case muri of
     Nothing -> do
       runLogger
         (logWarn $
-          "Could not find ChangeLog for " <> T.pack (prettyShow tool) <> ", version " <> T.pack (prettyShow ver')
+          "Could not find ChangeLog for " <> T.pack (prettyShow tool) <> ", version " <> either prettyVer (T.pack . show) ver'
         )
       pure ExitSuccess
     Just uri -> do

app/ghcup/GHCup/OptParse/Common.hs

@@ -5,7 +5,6 @@
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE TypeApplications #-}
 {-# LANGUAGE NumericUnderscores #-}
-{-# LANGUAGE ViewPatterns      #-}
 
 module GHCup.OptParse.Common where
 
@@ -46,8 +45,6 @@ import           Data.Functor
 import           Data.List                      ( nub, sort, sortBy, isPrefixOf, stripPrefix )
 import           Data.Maybe
 import           Data.Text                      ( Text )
-import           Data.Time.Calendar             ( Day )
-import           Data.Time.Format               ( parseTimeM, defaultTimeLocale )
 import           Data.Versions           hiding ( str )
 import           Data.Void
 import qualified Data.Vector      as V
@@ -75,26 +72,26 @@ import qualified Cabal.Config            as CC
     --[ Types ]--
     -------------
 
+data ToolVersion = GHCVersion GHCTargetVersion
+                 | ToolVersion Version
+                 | ToolTag Tag
 
 -- a superset of ToolVersion
 data SetToolVersion = SetGHCVersion GHCTargetVersion
                     | SetToolVersion Version
                     | SetToolTag Tag
-                    | SetToolDay Day
                     | SetRecommended
                     | SetNext
 
 prettyToolVer :: ToolVersion -> String
-prettyToolVer (GHCVersion v')  = T.unpack $ tVerToText v'
+prettyToolVer (GHCVersion v') = T.unpack $ tVerToText v'
 prettyToolVer (ToolVersion v') = T.unpack $ prettyVer v'
-prettyToolVer (ToolTag t)      = show t
+prettyToolVer (ToolTag t) = show t
-prettyToolVer (ToolDay day)    = show day
 
 toSetToolVer :: Maybe ToolVersion -> SetToolVersion
 toSetToolVer (Just (GHCVersion v')) = SetGHCVersion v'
 toSetToolVer (Just (ToolVersion v')) = SetToolVersion v'
 toSetToolVer (Just (ToolTag t')) = SetToolTag t'
-toSetToolVer (Just (ToolDay d')) = SetToolDay d'
 toSetToolVer Nothing = SetRecommended
 
 
@@ -105,28 +102,28 @@ toSetToolVer Nothing = SetRecommended
     --------------
 
 
-toolVersionTagArgument :: [ListCriteria] -> Maybe Tool -> Parser ToolVersion
+toolVersionTagArgument :: Maybe ListCriteria -> Maybe Tool -> Parser ToolVersion
 toolVersionTagArgument criteria tool =
   argument (eitherReader (parser tool))
     (metavar (mv tool)
     <> completer (tagCompleter (fromMaybe GHC tool) [])
     <> foldMap (completer . versionCompleter criteria) tool)
  where
-  mv (Just GHC) = "GHC_VERSION|TAG|RELEASE_DATE"
+  mv (Just GHC) = "GHC_VERSION|TAG"
-  mv (Just HLS) = "HLS_VERSION|TAG|RELEASE_DATE"
+  mv (Just HLS) = "HLS_VERSION|TAG"
-  mv _          = "VERSION|TAG|RELEASE_DATE"
+  mv _          = "VERSION|TAG"
 
   parser (Just GHC) = ghcVersionTagEither
   parser Nothing    = ghcVersionTagEither
   parser _          = toolVersionTagEither
 
 
-versionParser' :: [ListCriteria] -> Maybe Tool -> Parser Version
+versionParser' :: Maybe ListCriteria -> Maybe Tool -> Parser Version
 versionParser' criteria tool = argument
   (eitherReader (first show . version . T.pack))
   (metavar "VERSION"  <> foldMap (completer . versionCompleter criteria) tool)
 
-ghcVersionArgument :: [ListCriteria] -> Maybe Tool -> Parser GHCTargetVersion
+ghcVersionArgument :: Maybe ListCriteria -> Maybe Tool -> Parser GHCTargetVersion
 ghcVersionArgument criteria tool = argument (eitherReader ghcVersionEither)
                                             (metavar "VERSION" <> foldMap (completer . versionCompleter criteria) tool)
 
@@ -240,23 +237,22 @@ isolateParser f = case isValid f && isAbsolute f of
 -- this accepts cross prefix
 ghcVersionTagEither :: String -> Either String ToolVersion
 ghcVersionTagEither s' =
-  second ToolDay (dayParser s') <|> second ToolTag (tagEither s') <|> second GHCVersion (ghcVersionEither s')
+  second ToolTag (tagEither s') <|> second GHCVersion (ghcVersionEither s')
 
 -- this ignores cross prefix
 toolVersionTagEither :: String -> Either String ToolVersion
 toolVersionTagEither s' =
-  second ToolDay (dayParser s') <|> second ToolTag (tagEither s') <|> second ToolVersion (toolVersionEither s')
+  second ToolTag (tagEither s') <|> second ToolVersion (toolVersionEither s')
 
 tagEither :: String -> Either String Tag
 tagEither s' = case fmap toLower s' of
   "recommended"              -> Right Recommended
   "latest"                   -> Right Latest
   "latest-prerelease"        -> Right LatestPrerelease
-  "latest-nightly"           -> Right LatestNightly
   ('b':'a':'s':'e':'-':ver') -> case pvp (T.pack ver') of
                                   Right x -> Right (Base x)
                                   Left  _ -> Left $ "Invalid PVP version for base " <> ver'
-  other                      -> Left $ "Unknown tag " <> other
+  other         -> Left $ "Unknown tag " <> other
 
 
 ghcVersionEither :: String -> Either String GHCTargetVersion
@@ -265,7 +261,7 @@ ghcVersionEither =
 
 toolVersionEither :: String -> Either String Version
 toolVersionEither =
-  first (const "Not a valid version") . MP.parse (version' <* MP.eof) "" . T.pack
+  first (const "Not a valid version") . MP.parse version' "" . T.pack
 
 
 toolParser :: String -> Either String Tool
@@ -276,22 +272,12 @@ toolParser s' | t == T.pack "ghc"   = Right GHC
               | otherwise           = Left ("Unknown tool: " <> s')
   where t = T.toLower (T.pack s')
 
-dayParser :: String -> Either String Day
-dayParser s = maybe (Left $ "Could not parse \"" <> s <> "\". Expected format is: YYYY-MM-DD") Right
-            $ parseTimeM True defaultTimeLocale "%Y-%-m-%-d" s
-
 
 criteriaParser :: String -> Either String ListCriteria
-criteriaParser s' | t == T.pack "installed"   = Right $ ListInstalled True
+criteriaParser s' | t == T.pack "installed" = Right ListInstalled
-                  | t == T.pack "set"         = Right $ ListSet True
+                  | t == T.pack "set"       = Right ListSet
-                  | t == T.pack "available"   = Right $ ListAvailable True
+                  | t == T.pack "available" = Right ListAvailable
-                  | t == T.pack "+installed"  = Right $ ListInstalled True
+                  | otherwise               = Left ("Unknown criteria: " <> s')
-                  | t == T.pack "+set"        = Right $ ListSet True
-                  | t == T.pack "+available"  = Right $ ListAvailable True
-                  | t == T.pack "-installed"  = Right $ ListInstalled False
-                  | t == T.pack "-set"        = Right $ ListSet False
-                  | t == T.pack "-available"  = Right $ ListAvailable False
-                  | otherwise                 = Left ("Unknown criteria: " <> s')
   where t = T.toLower (T.pack s')
 
 
@@ -469,10 +455,10 @@ tagCompleter tool add = listIOCompleter $ do
       pure $ nub $ (add ++) $ fmap tagToString allTags
     VLeft _ -> pure  (nub $ ["recommended", "latest", "latest-prerelease"] ++ add)
 
-versionCompleter :: [ListCriteria] -> Tool -> Completer
+versionCompleter :: Maybe ListCriteria -> Tool -> Completer
 versionCompleter criteria tool = versionCompleter' criteria tool (const True)
 
-versionCompleter' :: [ListCriteria] -> Tool -> (Version -> Bool) -> Completer
+versionCompleter' :: Maybe ListCriteria -> Tool -> (Version -> Bool) -> Completer
 versionCompleter' criteria tool filter' = listIOCompleter $ do
   dirs' <- liftIO getAllDirs
   let loggerConfig = LoggerConfig
@@ -501,7 +487,7 @@ versionCompleter' criteria tool filter' = listIOCompleter $ do
 
           runEnv = flip runReaderT appState
 
-      installedVersions <- runEnv $ listVersions (Just tool) criteria False False (Nothing, Nothing)
+      installedVersions <- runEnv $ listVersions (Just tool) criteria
       return $ fmap (T.unpack . prettyVer) . filter filter' . fmap lVer $ installedVersions
 
 
@@ -669,7 +655,6 @@ fromVersion :: ( HasLog env
             -> Tool
             -> Excepts
                  '[ TagNotFound
-                  , DayNotFound
                   , NextVerNotFound
                   , NoToolVersionSet
                   ] m (GHCTargetVersion, Maybe VersionInfo)
@@ -688,58 +673,49 @@ fromVersion' :: ( HasLog env
              -> Tool
              -> Excepts
                   '[ TagNotFound
-                   , DayNotFound
                    , NextVerNotFound
                    , NoToolVersionSet
                    ] m (GHCTargetVersion, Maybe VersionInfo)
 fromVersion' SetRecommended tool = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  second Just <$> getRecommended dls tool
+  bimap mkTVer Just <$> getRecommended dls tool
     ?? TagNotFound Recommended tool
 fromVersion' (SetGHCVersion v) tool = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  let vi = getVersionInfo v tool dls
+  let vi = getVersionInfo (_tvVersion v) tool dls
   case pvp $ prettyVer (_tvVersion v) of -- need to be strict here
     Left _ -> pure (v, vi)
     Right pvpIn ->
-      lift (getLatestToolFor tool (_tvTarget v) pvpIn dls) >>= \case
+      lift (getLatestToolFor tool pvpIn dls) >>= \case
-        Just (pvp_, vi', mt) -> do
+        Just (pvp_, vi') -> do
           v' <- lift $ pvpToVersion pvp_ ""
           when (v' /= _tvVersion v) $ lift $ logWarn ("Assuming you meant version " <> prettyVer v')
-          pure (GHCTargetVersion mt v', Just vi')
+          pure (GHCTargetVersion (_tvTarget v) v', Just vi')
         Nothing -> pure (v, vi)
-fromVersion' (SetToolVersion (mkTVer -> v)) tool = do
+fromVersion' (SetToolVersion v) tool = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
   let vi = getVersionInfo v tool dls
-  case pvp $ prettyVer (_tvVersion v) of -- need to be strict here
+  case pvp $ prettyVer v of -- need to be strict here
-    Left _ -> pure (v, vi)
+    Left _ -> pure (mkTVer v, vi)
     Right pvpIn ->
-      lift (getLatestToolFor tool (_tvTarget v) pvpIn dls) >>= \case
+      lift (getLatestToolFor tool pvpIn dls) >>= \case
-        Just (pvp_, vi', mt) -> do
+        Just (pvp_, vi') -> do
           v' <- lift $ pvpToVersion pvp_ ""
-          when (v' /= _tvVersion v) $ lift $ logWarn ("Assuming you meant version " <> prettyVer v')
+          when (v' /= v) $ lift $ logWarn ("Assuming you meant version " <> prettyVer v')
-          pure (GHCTargetVersion mt v', Just vi')
+          pure (GHCTargetVersion mempty v', Just vi')
-        Nothing -> pure (v, vi)
+        Nothing -> pure (mkTVer v, vi)
 fromVersion' (SetToolTag Latest) tool = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  bimap id Just <$> getLatest dls tool ?? TagNotFound Latest tool
+  bimap mkTVer Just <$> getLatest dls tool ?? TagNotFound Latest tool
-fromVersion' (SetToolDay day) tool = do
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  bimap id Just <$> case getByReleaseDay dls tool day of
-                          Left ad -> throwE $ DayNotFound day tool ad
-                          Right v -> pure v
 fromVersion' (SetToolTag LatestPrerelease) tool = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  bimap id Just <$> getLatestPrerelease dls tool ?? TagNotFound LatestPrerelease tool
+  bimap mkTVer Just <$> getLatestPrerelease dls tool ?? TagNotFound LatestPrerelease tool
-fromVersion' (SetToolTag LatestNightly) tool = do
-  GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  bimap id Just <$> getLatestNightly dls tool ?? TagNotFound LatestNightly tool
 fromVersion' (SetToolTag Recommended) tool = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  bimap id Just <$> getRecommended dls tool ?? TagNotFound Recommended tool
+  bimap mkTVer Just <$> getRecommended dls tool ?? TagNotFound Recommended tool
 fromVersion' (SetToolTag (Base pvp'')) GHC = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  bimap id Just <$> getLatestBaseVersion dls pvp'' ?? TagNotFound (Base pvp'') GHC
+  bimap mkTVer Just <$> getLatestBaseVersion dls pvp'' ?? TagNotFound (Base pvp'') GHC
 fromVersion' SetNext tool = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
   next <- case tool of
@@ -784,7 +760,7 @@ fromVersion' SetNext tool = do
         . sort
         $ stacks) ?? NoToolVersionSet tool
     GHCup -> fail "GHCup cannot be set"
-  let vi = getVersionInfo next tool dls
+  let vi = getVersionInfo (_tvVersion next) tool dls
   pure (next, vi)
 fromVersion' (SetToolTag t') tool =
   throwE $ TagNotFound t' tool
@@ -800,15 +776,15 @@ checkForUpdates :: ( MonadReader env m
                    , MonadIO m
                    , MonadFail m
                    )
-                => m [(Tool, GHCTargetVersion)]
+                => m [(Tool, Version)]
 checkForUpdates = do
   GHCupInfo { _ghcupDownloads = dls } <- getGHCupInfo
-  lInstalled <- listVersions Nothing [ListInstalled True] False False (Nothing, Nothing)
+  lInstalled <- listVersions Nothing (Just ListInstalled)
-  let latestInstalled tool = (fmap (\lr -> GHCTargetVersion (lCross lr) (lVer lr)) . lastMay . filter (\lr -> lTool lr == tool)) lInstalled
+  let latestInstalled tool = (fmap lVer . lastMay . filter (\lr -> lTool lr == tool)) lInstalled
 
-  ghcup <- forMM (getLatest dls GHCup) $ \(GHCTargetVersion _ l, _) -> do
+  ghcup <- forMM (getLatest dls GHCup) $ \(l, _) -> do
     (Right ghcup_ver) <- pure $ version $ prettyPVP ghcUpVer
-    if (l > ghcup_ver) then pure $ Just (GHCup, mkTVer l) else pure Nothing
+    if (l > ghcup_ver) then pure $ Just (GHCup, l) else pure Nothing
 
   otherTools <- forM [GHC, Cabal, HLS, Stack] $ \t ->
     forMM (getLatest dls t) $ \(l, _) -> do

app/ghcup/GHCup/OptParse/Compile.hs

@@ -66,7 +66,7 @@ data CompileCommand = CompileGHC GHCCompileOptions
 
 
 data GHCCompileOptions = GHCCompileOptions
-  { targetGhc    :: GHC.GHCVer
+  { targetGhc    :: GHC.GHCVer Version
   , bootstrapGhc :: Either Version FilePath
   , jobs         :: Maybe Int
   , buildConfig  :: Maybe FilePath
@@ -76,7 +76,7 @@ data GHCCompileOptions = GHCCompileOptions
   , setCompile   :: Bool
   , ovewrwiteVer :: Maybe Version
   , buildFlavour :: Maybe String
-  , buildSystem  :: Maybe BuildSystem
+  , hadrian      :: Bool
   , isolateDir   :: Maybe FilePath
   }
 
@@ -170,7 +170,7 @@ ghcCompileOpts =
           )
           (short 'v' <> long "version" <> metavar "VERSION" <> help
             "The tool version to compile"
-            <> (completer $ versionCompleter [] GHC)
+            <> (completer $ versionCompleter Nothing GHC)
           )
           ) <|>
           (GHC.GitDist <$> (GitBranch <$> option
@@ -205,7 +205,7 @@ ghcCompileOpts =
           <> metavar "BOOTSTRAP_GHC"
           <> help
                "The GHC version (or full path) to bootstrap with (must be installed)"
-          <> (completer $ versionCompleter [] GHC)
+          <> (completer $ versionCompleter Nothing GHC)
           )
     <*> optional
           (option
@@ -258,7 +258,7 @@ ghcCompileOpts =
             )
             (short 'o' <> long "overwrite-version" <> metavar "OVERWRITE_VERSION" <> help
               "Allows to overwrite the finally installed VERSION with a different one, e.g. when you build 8.10.4 with your own patches, you might want to set this to '8.10.4-p1'"
-            <> (completer $ versionCompleter [] GHC)
+            <> (completer $ versionCompleter Nothing GHC)
             )
           )
     <*> optional
@@ -268,15 +268,9 @@ ghcCompileOpts =
               "Set the compile build flavour (this value depends on the build system type: 'make' vs 'hadrian')"
             )
           )
-    <*> (
+    <*> switch
-         (\b -> if b then Just Hadrian else Nothing) <$> switch
+          (long "hadrian" <> help "Use the hadrian build system instead of make (only git versions seem to be properly supported atm)"
-          (long "hadrian" <> help "Use the hadrian build system instead of make. Tries to detect by default."
           )
-         <|>
-         (\b -> if b then Just Make else Nothing) <$> switch
-          (long "make" <> help "Use the make build system instead of hadrian. Tries to detect by default."
-          )
-        )
     <*> optional
           (option
             (eitherReader isolateParser)
@@ -297,7 +291,7 @@ hlsCompileOpts =
           )
           (short 'v' <> long "version" <> metavar "VERSION" <> help
             "The version to compile (pulled from hackage)"
-            <> (completer $ versionCompleter' [] HLS (either (const False) (const True) . V.pvp . V.prettyVer))
+            <> (completer $ versionCompleter' Nothing HLS (either (const False) (const True) . V.pvp . V.prettyVer))
           )
           )
           <|>
@@ -317,7 +311,7 @@ hlsCompileOpts =
             )
           (long "source-dist" <> metavar "VERSION" <> help
             "The version to compile (pulled from packaged git sources)"
-            <> (completer $ versionCompleter [] HLS)
+            <> (completer $ versionCompleter Nothing HLS)
           )
           ))
           <|>
@@ -349,7 +343,7 @@ hlsCompileOpts =
             )
             (short 'o' <> long "overwrite-version" <> metavar "OVERWRITE_VERSION" <> help
               "Allows to overwrite the finally installed VERSION with a different one, e.g. when you build 8.10.4 with your own patches, you might want to set this to '8.10.4-p1'"
-            <> (completer $ versionCompleter [] HLS)
+            <> (completer $ versionCompleter Nothing HLS)
             )
           )
           <|>
@@ -409,7 +403,7 @@ hlsCompileOpts =
           option (eitherReader ghcVersionTagEither)
             (  long "ghc" <> metavar "GHC_VERSION|TAG" <> help "For which GHC version to compile for (can be specified multiple times)"
             <> completer (tagCompleter GHC [])
-            <> completer (versionCompleter [] GHC))
+            <> completer (versionCompleter Nothing GHC))
         )
     <*> many (argument str (metavar "CABAL_ARGS" <> help "Additional arguments to cabal install, prefix with '-- ' (longopts)"))
 
@@ -459,7 +453,6 @@ type HLSEffects = '[ AlreadyInstalled
                   , UnknownArchive
                   , TarDirDoesNotExist
                   , TagNotFound
-                  , DayNotFound
                   , NextVerNotFound
                   , NoToolVersionSet
                   , NotInstalled
@@ -517,7 +510,7 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
         case targetHLS of
           HLS.SourceDist targetVer -> do
             GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-            let vi = getVersionInfo (mkTVer targetVer) HLS dls
+            let vi = getVersionInfo targetVer HLS dls
             forM_ (_viPreCompile =<< vi) $ \msg -> do
               lift $ logInfo msg
               lift $ logInfo
@@ -537,7 +530,7 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
                     patches
                     cabalArgs
         GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-        let vi = getVersionInfo (mkTVer targetVer) HLS dls
+        let vi = getVersionInfo targetVer HLS dls
         when setCompile $ void $ liftE $
           setHLS targetVer SetHLSOnly Nothing
         pure (vi, targetVer)
@@ -561,12 +554,15 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
               VLeft e -> do
                 runLogger $ logError $ T.pack $ prettyHFError e
                 pure $ ExitFailure 9
+    (CompileGHC GHCCompileOptions { hadrian = True, crossTarget = Just _ }) -> do
+      runLogger $ logError "Hadrian cross compile support is not yet implemented!"
+      pure $ ExitFailure 9
     (CompileGHC GHCCompileOptions {..}) ->
       runCompileGHC runAppState (do
         case targetGhc of
           GHC.SourceDist targetVer -> do
             GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-            let vi = getVersionInfo (mkTVer targetVer) GHC dls
+            let vi = getVersionInfo targetVer GHC dls
             forM_ (_viPreCompile =<< vi) $ \msg -> do
               lift $ logInfo msg
               lift $ logInfo
@@ -574,8 +570,10 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
               liftIO $ threadDelay 5000000 -- for compilation, give the user a sec to intervene
           _ -> pure ()
         targetVer <- liftE $ compileGHC
-                    targetGhc
+                    ((\case
-                    crossTarget
+                        GHC.SourceDist v -> GHC.SourceDist $ GHCTargetVersion crossTarget v
+                        GHC.GitDist g -> GHC.GitDist g
+                        GHC.RemoteDist r -> GHC.RemoteDist r) targetGhc)
                     ovewrwiteVer
                     bootstrapGhc
                     jobs
@@ -583,10 +581,10 @@ compile compileCommand settings Dirs{..} runAppState runLogger = do
                     patches
                     addConfArgs
                     buildFlavour
-                    buildSystem
+                    hadrian
                     (maybe GHCupInternal IsolateDir isolateDir)
         GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-        let vi = getVersionInfo targetVer GHC dls
+        let vi = getVersionInfo (_tvVersion targetVer) GHC dls
         when setCompile $ void $ liftE $
           setGHC targetVer SetGHCOnly Nothing
         pure (vi, targetVer)

app/ghcup/GHCup/OptParse/Install.hs

@@ -184,7 +184,7 @@ installOpts tool =
                       <> completer (toolDlCompleter (fromMaybe GHC tool))
                     )
                   )
-            <*> (Just <$> toolVersionTagArgument [] tool)
+            <*> (Just <$> toolVersionTagArgument Nothing tool)
             )
         <|> pure (Nothing, Nothing)
         )
@@ -241,7 +241,6 @@ type InstallEffects = '[ AlreadyInstalled
                        , NotInstalled
                        , BuildFailed
                        , TagNotFound
-                       , DayNotFound
                        , DigestError
                        , ContentLengthError
                        , GPGError
@@ -285,7 +284,6 @@ type InstallGHCEffects = '[ AlreadyInstalled
                           , NotInstalled
                           , ProcessError
                           , TagNotFound
-                          , DayNotFound
                           , TarDirDoesNotExist
                           , UninstallFailed
                           , UnknownArchive
@@ -324,7 +322,7 @@ install installCommand settings getAppState' runLogger = case installCommand of
        Nothing -> runInstGHC s' $ do
          (v, vi) <- liftE $ fromVersion instVer GHC
          liftE $ runBothE' (installGHCBin
-                     v
+                     (_tvVersion v)
                      (maybe GHCupInternal IsolateDir isolateDir)
                      forceInstall
                      addConfArgs
@@ -335,8 +333,8 @@ install installCommand settings getAppState' runLogger = case installCommand of
          runInstGHC s'{ settings = settings {noVerify = True}} $ do
            (v, vi) <- liftE $ fromVersion instVer GHC
            liftE $ runBothE' (installGHCBindist
-                       (DownloadInfo uri (Just $ RegexDir "ghc-.*") "" Nothing Nothing)
+                       (DownloadInfo uri (Just $ RegexDir "ghc-.*") "" Nothing)
-                       v
+                       (_tvVersion v)
                        (maybe GHCupInternal IsolateDir isolateDir)
                        forceInstall
                        addConfArgs
@@ -405,7 +403,7 @@ install installCommand settings getAppState' runLogger = case installCommand of
          runInstTool s'{ settings = settings { noVerify = True}} $ do
            (_tvVersion -> v, vi) <- liftE $ fromVersion instVer Cabal
            liftE $ runBothE' (installCabalBindist
-                                      (DownloadInfo uri Nothing "" Nothing Nothing)
+                                      (DownloadInfo uri Nothing "" Nothing)
                                       v
                                       (maybe GHCupInternal IsolateDir isolateDir)
                                       forceInstall
@@ -455,7 +453,7 @@ install installCommand settings getAppState' runLogger = case installCommand of
            (_tvVersion -> v, vi) <- liftE $ fromVersion instVer HLS
            -- TODO: support legacy
            liftE $ runBothE' (installHLSBindist
-                                      (DownloadInfo uri (if isWindows then Nothing else Just (RegexDir "haskell-language-server-*")) "" Nothing Nothing)
+                                      (DownloadInfo uri (if isWindows then Nothing else Just (RegexDir "haskell-language-server-*")) "" Nothing)
                                       v
                                       (maybe GHCupInternal IsolateDir isolateDir)
                                       forceInstall
@@ -504,7 +502,7 @@ install installCommand settings getAppState' runLogger = case installCommand of
           runInstTool s'{ settings = settings { noVerify = True}} $ do
             (_tvVersion -> v, vi) <- liftE $ fromVersion instVer Stack
             liftE $ runBothE' (installStackBindist
-                                       (DownloadInfo uri Nothing "" Nothing Nothing)
+                                       (DownloadInfo uri Nothing "" Nothing)
                                        v
                                        (maybe GHCupInternal IsolateDir isolateDir)
                                        forceInstall

app/ghcup/GHCup/OptParse/List.hs

@@ -2,7 +2,6 @@
 {-# LANGUAGE DataKinds         #-}
 {-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE OverloadedStrings #-}
-{-# LANGUAGE QuasiQuotes       #-}
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE RankNTypes #-}
 
@@ -15,7 +14,6 @@ import           GHCup
 import           GHCup.Prelude
 import           GHCup.Types
 import           GHCup.OptParse.Common
-import           GHCup.Prelude.String.QQ
 
 #if !MIN_VERSION_base(4,13,0)
 import           Control.Monad.Fail             ( MonadFail )
@@ -26,7 +24,6 @@ import           Data.Char
 import           Data.List                      ( intercalate, sort )
 import           Data.Functor
 import           Data.Maybe
-import           Data.Time.Calendar             ( Day )
 import           Data.Versions           hiding ( str )
 import           Data.Void
 import           Options.Applicative     hiding ( style )
@@ -53,10 +50,6 @@ import qualified Text.Megaparsec.Char          as MPC
 data ListOptions = ListOptions
   { loTool     :: Maybe Tool
   , lCriteria  :: Maybe ListCriteria
-  , lFrom      :: Maybe Day
-  , lTo        :: Maybe Day
-  , lHideOld   :: Bool
-  , lShowNightly :: Bool
   , lRawFormat :: Bool
   }
 
@@ -67,6 +60,7 @@ data ListOptions = ListOptions
     --[ Parsers ]--
     ---------------
 
+          
 listOpts :: Parser ListOptions
 listOpts =
   ListOptions
@@ -75,7 +69,7 @@ listOpts =
             (eitherReader toolParser)
             (short 't' <> long "tool" <> metavar "<ghc|cabal|hls|stack>" <> help
               "Tool to list versions for. Default is all"
-              <> completer toolCompleter
+              <> completer (toolCompleter)
             )
           )
     <*> optional
@@ -84,53 +78,15 @@ listOpts =
             (  short 'c'
             <> long "show-criteria"
             <> metavar "<installed|set|available>"
-            <> help "Apply filtering criteria, prefix with + or -"
+            <> help "Show only installed/set/available tool versions"
-              <> completer (listCompleter
+              <> completer (listCompleter ["installed", "set", "available"])
-                [ "+installed", "+set", "+available", "-installed", "-set", "-available"])
             )
           )
-    <*> optional
-          (option
-            (eitherReader dayParser)
-            (short 's' <> long "since" <> metavar "YYYY-MM-DD" <> help
-              "List only tools with release date starting at YYYY-MM-DD or later"
-              <> completer toolCompleter
-            )
-          )
-    <*> optional
-          (option
-            (eitherReader dayParser)
-            (short 'u' <> long "until" <> metavar "YYYY-MM-DD" <> help
-              "List only tools with release date earlier than YYYY-MM-DD"
-              <> completer toolCompleter
-            )
-          )
-    <*> switch
-          (short 'o' <> long "hide-old" <> help "Hide 'old' GHC versions (installed ones are always shown)"
-          )
-    <*> switch
-          (short 'n' <> long "show-nightly" <> help "Show nightlies (installed ones are always shown)"
-          )
     <*> switch
           (short 'r' <> long "raw-format" <> help "More machine-parsable format"
           )
 
 
-    --------------
-    --[ Footer ]--
-    --------------
-
-
-listToolFooter :: String
-listToolFooter = [s|Discussion:
-  Lists tool versions with optional criteria.
-  Nightlies are by default hidden.
-
-Examples:
-  # query nightlies in a specific range
-  ghcup list --show-nightly --since 2022-12-07 --until 2022-12-31
-  # show all installed GHC versions
-  ghcup list -t ghc -c installed|]
 
 
     -----------------
@@ -149,11 +105,9 @@ printListResult no_color raw lr = do
     printTag Recommended        = color Green "recommended"
     printTag Latest             = color Yellow "latest"
     printTag Prerelease         = color Red "prerelease"
-    printTag Nightly            = color Red "nightly"
     printTag (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
     printTag (UnknownTag t    ) = t
     printTag LatestPrerelease   = color Red "latest-prerelease"
-    printTag LatestNightly      = color Red "latest-nightly"
     printTag Old                = ""
 
   let
@@ -180,10 +134,8 @@ printListResult no_color raw lr = do
                           then [color Green "hls-powered"]
                           else mempty
                         )
+                     ++ (if fromSrc then [color Blue "compiled"] else mempty)
                      ++ (if lStray then [color Yellow "stray"] else mempty)
-                     ++ (case lReleaseDay of
-                           Nothing -> mempty
-                           Just d  -> [color Blue (show d)])
                      ++ (if lNoBindist
                           then [color Red "no-bindist"]
                           else mempty
@@ -308,7 +260,7 @@ list :: ( Monad m
       -> m ExitCode
 list ListOptions{..} no_color runAppState =
   runAppState (do
-      l <- listVersions loTool (maybeToList lCriteria) lHideOld lShowNightly (lFrom, lTo)
+      l <- listVersions loTool lCriteria
       liftIO $ printListResult no_color lRawFormat l
       pure ExitSuccess
     )

app/ghcup/GHCup/OptParse/Nuke.hs

@@ -76,8 +76,8 @@ nuke appState runLogger = do
 
        lift $ logInfo "Initiating Nuclear Sequence 🚀🚀🚀"
        lift $ logInfo "Nuking in 3...2...1"
-
+  
-       lInstalled <- lift $ listVersions Nothing [ListInstalled True] False True (Nothing, Nothing)
+       lInstalled <- lift $ listVersions Nothing (Just ListInstalled)
 
        forM_ lInstalled (liftE . rmTool)
 

app/ghcup/GHCup/OptParse/Prefetch.hs

@@ -83,7 +83,7 @@ prefetchP = subparser
           <$> (PrefetchGHCOptions
                 <$> ( switch (short 's' <> long "source" <> help "Download source tarball instead of bindist") <**> helper )
                 <*> optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
-          <*>  optional (toolVersionTagArgument [] (Just GHC)) )
+          <*>  optional (toolVersionTagArgument Nothing (Just GHC)) )
         ( progDesc "Download GHC assets for installation")
       )
       <>
@@ -92,7 +92,7 @@ prefetchP = subparser
       (info
         (PrefetchCabal
           <$> fmap PrefetchOptions (optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
-          <*> ( optional (toolVersionTagArgument [] (Just Cabal)) <**> helper ))
+          <*> ( optional (toolVersionTagArgument Nothing (Just Cabal)) <**> helper ))
         ( progDesc "Download cabal assets for installation")
       )
       <>
@@ -101,7 +101,7 @@ prefetchP = subparser
       (info
         (PrefetchHLS
           <$> fmap PrefetchOptions (optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
-          <*> ( optional (toolVersionTagArgument [] (Just HLS)) <**> helper ))
+          <*> ( optional (toolVersionTagArgument Nothing (Just HLS)) <**> helper ))
         ( progDesc "Download HLS assets for installation")
       )
       <>
@@ -110,7 +110,7 @@ prefetchP = subparser
       (info
         (PrefetchStack
           <$> fmap PrefetchOptions (optional (option str (short 'd' <> long "directory" <> help "directory to download into (default: ~/.ghcup/cache/)" <> completer (bashCompleter "directory"))))
-          <*> ( optional (toolVersionTagArgument [] (Just Stack)) <**> helper ))
+          <*> ( optional (toolVersionTagArgument Nothing (Just Stack)) <**> helper ))
         ( progDesc "Download stack assets for installation")
       )
       <>
@@ -148,7 +148,6 @@ Examples:
 
 
 type PrefetchEffects = '[ TagNotFound
-                        , DayNotFound
                         , NextVerNotFound
                         , NoToolVersionSet
                         , NoDownload
@@ -195,7 +194,7 @@ prefetch prefetchCommand runAppState runLogger =
           forM_ pfCacheDir (liftIO . createDirRecursive')
           (v, _) <- liftE $ fromVersion mt GHC
           if pfGHCSrc
-          then liftE $ fetchGHCSrc v pfCacheDir
+          then liftE $ fetchGHCSrc (_tvVersion v) pfCacheDir
           else liftE $ fetchToolBindist (_tvVersion v) GHC pfCacheDir
       PrefetchCabal PrefetchOptions {pfCacheDir} mt   -> do
         forM_ pfCacheDir (liftIO . createDirRecursive')

app/ghcup/GHCup/OptParse/Rm.hs

@@ -80,19 +80,19 @@ rmParser =
       <> command
            "cabal"
            (   RmCabal
-           <$> info (versionParser' [ListInstalled True] (Just Cabal) <**> helper)
+           <$> info (versionParser' (Just ListInstalled) (Just Cabal) <**> helper)
                     (progDesc "Remove Cabal version")
            )
       <> command
            "hls"
            (   RmHLS
-           <$> info (versionParser' [ListInstalled True] (Just HLS) <**> helper)
+           <$> info (versionParser' (Just ListInstalled) (Just HLS) <**> helper)
                     (progDesc "Remove haskell-language-server version")
            )
       <> command
            "stack"
            (   RmStack
-           <$> info (versionParser' [ListInstalled True] (Just Stack) <**> helper)
+           <$> info (versionParser' (Just ListInstalled) (Just Stack) <**> helper)
                     (progDesc "Remove stack version")
            )
       )
@@ -102,7 +102,7 @@ rmParser =
 
 
 rmOpts :: Maybe Tool -> Parser RmOptions
-rmOpts tool = RmOptions <$> ghcVersionArgument [ListInstalled True] tool
+rmOpts tool = RmOptions <$> ghcVersionArgument (Just ListInstalled) tool
 
 
 
@@ -170,7 +170,7 @@ rm rmCommand runAppState runLogger = case rmCommand of
         liftE $
           rmGHCVer ghcVer
         GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-        pure (getVersionInfo ghcVer GHC dls)
+        pure (getVersionInfo (_tvVersion ghcVer) GHC dls)
       )
       >>= \case
             VRight vi -> do
@@ -186,7 +186,7 @@ rm rmCommand runAppState runLogger = case rmCommand of
         liftE $
           rmCabalVer tv
         GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-        pure (getVersionInfo (mkTVer tv) Cabal dls)
+        pure (getVersionInfo tv Cabal dls)
       )
       >>= \case
             VRight vi -> do
@@ -201,7 +201,7 @@ rm rmCommand runAppState runLogger = case rmCommand of
         liftE $
           rmHLSVer tv
         GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-        pure (getVersionInfo (mkTVer tv) HLS dls)
+        pure (getVersionInfo tv HLS dls)
       )
       >>= \case
             VRight vi -> do
@@ -216,7 +216,7 @@ rm rmCommand runAppState runLogger = case rmCommand of
         liftE $
           rmStackVer tv
         GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-        pure (getVersionInfo (mkTVer tv) Stack dls)
+        pure (getVersionInfo tv Stack dls)
       )
       >>= \case
             VRight vi -> do

app/ghcup/GHCup/OptParse/Run.hs

@@ -92,7 +92,7 @@ runOpts =
             (eitherReader ghcVersionTagEither)
             (metavar "GHC_VERSION" <> long "ghc" <> help "The ghc version"
             <> completer (tagCompleter GHC [])
-            <> (completer $ versionCompleter [] GHC)
+            <> (completer $ versionCompleter Nothing GHC)
             )
           )
     <*> optional
@@ -100,7 +100,7 @@ runOpts =
             (eitherReader toolVersionTagEither)
             (metavar "CABAL_VERSION" <> long "cabal" <> help "The cabal version"
             <> completer (tagCompleter Cabal [])
-            <> (completer $ versionCompleter [] Cabal)
+            <> (completer $ versionCompleter Nothing Cabal)
             )
           )
     <*> optional
@@ -108,7 +108,7 @@ runOpts =
             (eitherReader toolVersionTagEither)
             (metavar "HLS_VERSION" <> long "hls" <> help "The HLS version"
             <> completer (tagCompleter HLS [])
-            <> (completer $ versionCompleter [] HLS)
+            <> (completer $ versionCompleter Nothing HLS)
             )
           )
     <*> optional
@@ -116,7 +116,7 @@ runOpts =
             (eitherReader toolVersionTagEither)
             (metavar "STACK_VERSION" <> long "stack" <> help "The stack version"
             <> completer (tagCompleter Stack [])
-            <> (completer $ versionCompleter [] Stack)
+            <> (completer $ versionCompleter Nothing Stack)
             )
           )
     <*> optional
@@ -132,7 +132,7 @@ runOpts =
     <*> switch
           (short 'q' <> long "quick" <> help "Avoid any expensive work (such as downloads, version/tag resolution etc.). Disables --install.")
     <*> many (argument str (metavar "COMMAND" <> help "The command to run, with arguments (use longopts --). If omitted, just prints the created bin/ dir to stdout and exits."))
-
+          
 
 
 
@@ -175,7 +175,6 @@ type RunEffects = '[ AlreadyInstalled
                    , NotInstalled
                    , BuildFailed
                    , TagNotFound
-                   , DayNotFound
                    , DigestError
                    , ContentLengthError
                    , GPGError
@@ -283,7 +282,6 @@ run RunOptions{..} runAppState leanAppstate runLogger = do
                            )
                         => Excepts
                              '[ TagNotFound
-                              , DayNotFound
                               , NextVerNotFound
                               , NoToolVersionSet
                               ] (ResourceT (ReaderT AppState m)) Toolchain
@@ -334,7 +332,6 @@ run RunOptions{..} runAppState leanAppstate runLogger = do
                         -> FilePath
                         -> Excepts
                              '[ TagNotFound
-                              , DayNotFound
                               , NextVerNotFound
                               , NoToolVersionSet
                               , UnknownArchive
@@ -360,7 +357,7 @@ run RunOptions{..} runAppState leanAppstate runLogger = do
            Just v -> do
              isInstalled <- lift $ checkIfToolInstalled' GHC v
              unless isInstalled $ when (runInstTool' && isNothing (_tvTarget v)) $ void $ liftE $ installGHCBin
-               v
+               (_tvVersion v)
                GHCupInternal
                False
                []

app/ghcup/GHCup/OptParse/Set.hs

@@ -139,9 +139,9 @@ setParser =
 setOpts :: Tool -> Parser SetOptions
 setOpts tool = SetOptions <$>
     (fromMaybe SetRecommended <$>
-      optional (setVersionArgument [ListInstalled True] tool))
+      optional (setVersionArgument (Just ListInstalled) tool))
 
-setVersionArgument :: [ListCriteria] -> Tool -> Parser SetToolVersion
+setVersionArgument :: Maybe ListCriteria -> Tool -> Parser SetToolVersion
 setVersionArgument criteria tool =
   argument (eitherReader setEither)
     (metavar "VERSION|TAG|next"
@@ -184,7 +184,6 @@ setFooter = [s|Discussion:
 type SetGHCEffects = '[ FileDoesNotExistError
                    , NotInstalled
                    , TagNotFound
-                   , DayNotFound
                    , NextVerNotFound
                    , NoToolVersionSet]
 
@@ -199,7 +198,6 @@ runSetGHC runAppState =
 
 type SetCabalEffects = '[ NotInstalled
                         , TagNotFound
-                        , DayNotFound
                         , NextVerNotFound
                         , NoToolVersionSet]
 
@@ -214,7 +212,6 @@ runSetCabal runAppState =
 
 type SetHLSEffects = '[ NotInstalled
                       , TagNotFound
-                      , DayNotFound
                       , NextVerNotFound
                       , NoToolVersionSet]
 
@@ -229,7 +226,6 @@ runSetHLS runAppState =
 
 type SetStackEffects = '[ NotInstalled
                         , TagNotFound
-                        , DayNotFound
                         , NextVerNotFound
                         , NoToolVersionSet]
 

app/ghcup/GHCup/OptParse/Test.hs

@@ -112,7 +112,7 @@ testOpts tool =
                       <> completer (toolDlCompleter (fromMaybe GHC tool))
                     )
                   )
-            <*> (Just <$> toolVersionTagArgument [] tool)
+            <*> (Just <$> toolVersionTagArgument Nothing tool)
             )
         <|> pure (Nothing, Nothing)
         )
@@ -140,7 +140,6 @@ type TestGHCEffects = [ DigestError
                       , TestFailed
                       , NextVerNotFound
                       , TagNotFound
-                      , DayNotFound
                       , NoToolVersionSet
                       ]
 
@@ -169,12 +168,12 @@ test testCommand settings getAppState' runLogger = case testCommand of
     (case testBindist of
        Nothing -> runTestGHC s' $ do
          (v, vi) <- liftE $ fromVersion testVer GHC
-         liftE $ testGHCVer v addMakeArgs
+         liftE $ testGHCVer (_tvVersion v) addMakeArgs
          pure vi
        Just uri -> do
          runTestGHC s'{ settings = settings {noVerify = True}} $ do
            (v, vi) <- liftE $ fromVersion testVer GHC
-           liftE $ testGHCBindist (DownloadInfo uri (Just $ RegexDir ".*/.*") "" Nothing Nothing) v addMakeArgs
+           liftE $ testGHCBindist (DownloadInfo uri (Just $ RegexDir ".*/.*") "" Nothing) (_tvVersion v) addMakeArgs
            pure vi
       )
         >>= \case

app/ghcup/GHCup/OptParse/Whereis.hs

@@ -82,7 +82,7 @@ whereisP = subparser
     command
       "ghc"
       (WhereisTool GHC <$> info
-        ( optional (toolVersionTagArgument [] (Just GHC)) <**> helper )
+        ( optional (toolVersionTagArgument Nothing (Just GHC)) <**> helper )
         ( progDesc "Get GHC location"
         <> footerDoc (Just $ text whereisGHCFooter ))
       )
@@ -90,7 +90,7 @@ whereisP = subparser
      command
       "cabal"
       (WhereisTool Cabal <$> info
-        ( optional (toolVersionTagArgument [] (Just Cabal)) <**> helper )
+        ( optional (toolVersionTagArgument Nothing (Just Cabal)) <**> helper )
         ( progDesc "Get cabal location"
         <> footerDoc (Just $ text whereisCabalFooter ))
       )
@@ -98,7 +98,7 @@ whereisP = subparser
      command
       "hls"
       (WhereisTool HLS <$> info
-        ( optional (toolVersionTagArgument [] (Just HLS)) <**> helper )
+        ( optional (toolVersionTagArgument Nothing (Just HLS)) <**> helper )
         ( progDesc "Get HLS location"
         <> footerDoc (Just $ text whereisHLSFooter ))
       )
@@ -106,7 +106,7 @@ whereisP = subparser
      command
       "stack"
       (WhereisTool Stack <$> info
-        ( optional (toolVersionTagArgument [] (Just Stack)) <**> helper )
+        ( optional (toolVersionTagArgument Nothing (Just Stack)) <**> helper )
         ( progDesc "Get stack location"
         <> footerDoc (Just $ text whereisStackFooter ))
       )
@@ -222,7 +222,6 @@ type WhereisEffects = '[ NotInstalled
                 , NoToolVersionSet
                 , NextVerNotFound
                 , TagNotFound
-                , DayNotFound
                 ]
 
 

app/ghcup/Main.hs

@@ -181,15 +181,13 @@ Report bugs at <https://github.com/haskell/ghcup-hs/issues>|]
           -- logger interpreter
           logfile <- runReaderT initGHCupFileLogging dirs
           no_color <- isJust <$> lookupEnv "NO_COLOR"
-          liftIO $ hSetBuffering stderr LineBuffering
-          liftIO $ hSetBuffering logfile LineBuffering
           let loggerConfig = LoggerConfig
                 { lcPrintDebug = verbose settings
                 , consoleOutter  = T.hPutStr stderr
                 , fileOutter    =
                     case optCommand of
                       Nuke -> \_ -> pure ()
-                      _ -> T.hPutStr logfile
+                      _ -> T.appendFile logfile
                 , fancyColors = not no_color
                 }
           let leanAppstate = LeanAppState settings dirs keybindings loggerConfig
@@ -242,7 +240,7 @@ Report bugs at <https://github.com/haskell/ghcup-hs/issues>|]
                   _
                     | Just False <- optVerbose -> pure ()
                     | otherwise -> lookupEnv "GHCUP_SKIP_UPDATE_CHECK" >>= \case
-                         Nothing -> void . flip runReaderT s' . runE @'[TagNotFound, DayNotFound, NextVerNotFound, NoToolVersionSet] $ do
+                         Nothing -> void . flip runReaderT s' . runE @'[TagNotFound, NextVerNotFound, NoToolVersionSet] $ do
                            newTools <- lift checkForUpdates
                            forM_ newTools $ \newTool@(t, l) -> do
                              -- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/283
@@ -251,7 +249,7 @@ Report bugs at <https://github.com/haskell/ghcup-hs/issues>|]
                                case t of
                                  GHCup -> runLogger $
                                             logWarn ("New GHCup version available: "
-                                              <> tVerToText l
+                                              <> prettyVer l
                                               <> ". To upgrade, run 'ghcup upgrade'")
                                  _ -> runLogger $
                                         logWarn ("New "
@@ -260,7 +258,7 @@ Report bugs at <https://github.com/haskell/ghcup-hs/issues>|]
                                           <> "If you want to install this latest version, run 'ghcup install "
                                           <> T.pack (prettyShow t)
                                           <> " "
-                                          <> tVerToText l
+                                          <> prettyVer l
                                           <> "'")
                          Just _ -> pure ()
 
@@ -334,10 +332,9 @@ Report bugs at <https://github.com/haskell/ghcup-hs/issues>|]
                        , MonadCatch m
                        )
                     => Command
-                    -> (Tool, GHCTargetVersion)
+                    -> (Tool, Version)
                     -> Excepts
                          '[ TagNotFound
-                          , DayNotFound
                           , NextVerNotFound
                           , NoToolVersionSet
                           ] m Bool
@@ -370,13 +367,12 @@ Report bugs at <https://github.com/haskell/ghcup-hs/issues>|]
           )
        => Tool
        -> Maybe ToolVersion
-       -> GHCTargetVersion
+       -> Version
        -> Excepts
             '[ TagNotFound
-             , DayNotFound
              , NextVerNotFound
              , NoToolVersionSet
              ] m Bool
   cmp' tool instVer ver = do
     (v, _) <- liftE $ fromVersion instVer tool
-    pure (v == ver)
+    pure (v == mkTVer ver)

docker/alpine32/Dockerfile

@@ -37,8 +37,8 @@ RUN apk add --no-cache \
             xz-dev \
             ncurses-static
 
-ARG GHCUP_VERSION=0.1.19.4
+ARG GHCUP_VERSION=0.1.18.0
-ARG GPG_KEY=7D1E8AFD1D4A16D71FADA2F2CCC85C0E40C06A8C
+ARG GPG_KEY=7784930957807690A66EBDBE3786C5262ECB4A3F
 
 # install ghcup
 RUN gpg --batch --keyserver keys.openpgp.org --recv-keys $GPG_KEY && \

docker/alpine64/Dockerfile

@@ -37,9 +37,8 @@ RUN apk add --no-cache \
             xz-dev \
             ncurses-static
 
-ARG GHCUP_VERSION=0.1.19.4
+ARG GHCUP_VERSION=0.1.18.0
-ARG GPG_KEY=7D1E8AFD1D4A16D71FADA2F2CCC85C0E40C06A8C
+ARG GPG_KEY=7784930957807690A66EBDBE3786C5262ECB4A3F
-
 
 # install ghcup
 RUN gpg --batch --keyserver keys.openpgp.org --recv-keys $GPG_KEY && \

docker/arm32v7/buster/Dockerfile

@@ -29,8 +29,8 @@ RUN apt-get update && \
 
 RUN update_opt.sh 11 1
 
-ARG GHCUP_VERSION=0.1.19.4
+ARG GHCUP_VERSION=0.1.17.8
-ARG GPG_KEY=7D1E8AFD1D4A16D71FADA2F2CCC85C0E40C06A8C
+ARG GPG_KEY=7784930957807690A66EBDBE3786C5262ECB4A3F
 
 # install ghcup
 RUN gpg --batch --keyserver keys.openpgp.org --recv-keys $GPG_KEY && \

docker/arm32v7/focal/Dockerfile

@@ -29,8 +29,8 @@ RUN apt-get update && \
 
 RUN update_opt.sh 9 1
 
-ARG GHCUP_VERSION=0.1.19.4
+ARG GHCUP_VERSION=0.1.17.8
-ARG GPG_KEY=7D1E8AFD1D4A16D71FADA2F2CCC85C0E40C06A8C
+ARG GPG_KEY=7784930957807690A66EBDBE3786C5262ECB4A3F
 
 # install ghcup
 RUN gpg --batch --keyserver keys.openpgp.org --recv-keys $GPG_KEY && \

docker/arm64v8/buster/Dockerfile

@@ -29,8 +29,8 @@ RUN apt-get update && \
 
 RUN update_opt.sh 11 1
 
-ARG GHCUP_VERSION=0.1.19.4
+ARG GHCUP_VERSION=0.1.18.0
-ARG GPG_KEY=7D1E8AFD1D4A16D71FADA2F2CCC85C0E40C06A8C
+ARG GPG_KEY=7784930957807690A66EBDBE3786C5262ECB4A3F
 
 # install ghcup
 RUN gpg --batch --keyserver keys.openpgp.org --recv-keys $GPG_KEY && \

docker/arm64v8/focal/Dockerfile

@@ -29,8 +29,8 @@ RUN apt-get update && \
 
 RUN update_opt.sh 9 1
 
-ARG GHCUP_VERSION=0.1.19.4
+ARG GHCUP_VERSION=0.1.18.0
-ARG GPG_KEY=7D1E8AFD1D4A16D71FADA2F2CCC85C0E40C06A8C
+ARG GPG_KEY=7784930957807690A66EBDBE3786C5262ECB4A3F
 
 # install ghcup
 RUN gpg --batch --keyserver keys.openpgp.org --recv-keys $GPG_KEY && \

docs/guide.md

@@ -203,34 +203,6 @@ url-source:
   - "https://raw.githubusercontent.com/haskell/ghcup-metadata/master/ghcup-prereleases-0.0.7.yaml"
 ```
 
-### Nightlies
-
-Nightlies are just another release channel. Currently, only GHC supports nightlies, which are binary releases
-that are built every night from `master`.
-
-To add the nightly channel, run:
-
-```sh
-ghcup config add-release-channel https://ghc.gitlab.haskell.org/ghcup-metadata/ghcup-nightlies-0.0.7.yaml
-```
-
-To list all nightlies from 2023, run:
-
-```sh
-ghcup list --show-nightly --tool=ghc --since=2023-01-01
-```
-
-Ways to install a nightly:
-
-```sh
-# by date
-ghcup install ghc 2023-06-20
-# by version
-ghcup install ghc 9.7.20230619
-# by tag
-ghcup install ghc latest-nightly
-```
-
 ## Stack integration
 
 Stack manages GHC versions internally by default. In order to make it use ghcup installed
@@ -489,7 +461,7 @@ this is cryptographically secure.
 First, obtain the gpg keys:
 
 ```sh
-gpg --batch --keyserver keys.openpgp.org     --recv-keys 7D1E8AFD1D4A16D71FADA2F2CCC85C0E40C06A8C
+gpg --batch --keyserver keys.openpgp.org     --recv-keys 7784930957807690A66EBDBE3786C5262ECB4A3F
 gpg --batch --keyserver keyserver.ubuntu.com --recv-keys FE5AB6C91FEA597C3B31180B73EDE9E8CFBAEF01
 ```
 

docs/install.md

@@ -77,8 +77,6 @@ On Darwin M1 you might also need a working llvm installed (e.g. via brew) and ha
 
 The following distro packages are required: `curl gcc gmp gmake ncurses perl5 libffi libiconv`
 
-Notice that only FreeBSD 13.x is supported. If the installation fails, complaining about `libncursesw.8.so`, you will need to install FreeBSD 12 compat package first, for example, `pkg install misc/compat12x`.
-
 ### Windows
 
 On Windows, msys2 should already have been set up during the installation, so most users should just proceed. If you are installing manually, make sure to have a working mingw64 toolchain and shell.
@@ -104,13 +102,9 @@ GHCup supports the following tools, which are also known as the **Haskell Toolch
 <table>
 <thead><tr><th>GHC Version</th><th>Tags</th></tr></thead>
 <tbody>
-<tr><td>9.6.1</td><td><span style="color:blue">latest</span>, base-4.18.0.0</td></tr>
+<tr><td>9.4.3</td><td><span style="color:blue">latest</span>, base-4.17.0.0</td></tr>
-<tr><td>9.4.4</td><td>base-4.17.0.0</td></tr>
-<tr><td>9.4.3</td><td>base-4.17.0.0</td></tr>
 <tr><td>9.4.2</td><td>base-4.17.0.0</td></tr>
 <tr><td>9.4.1</td><td>base-4.17.0.0</td></tr>
-<tr><td>9.2.7</td><td>base-4.16.4.0</td></tr>
-<tr><td>9.2.6</td><td>base-4.16.4.0</td></tr>
 <tr><td>9.2.5</td><td><span style="color:green">recommended</span>, base-4.16.4.0</td></tr>
 <tr><td>9.2.4</td><td>base-4.16.3.0</td></tr>
 <tr><td>9.2.3</td><td>base-4.16.2.0</td></tr>
@@ -149,8 +143,7 @@ GHCup supports the following tools, which are also known as the **Haskell Toolch
 <table>
 <thead><tr><th>Cabal Version</th><th>Tags</th></tr></thead>
 <tbody>
-<tr><td>3.10.1.0</td><td><span style="color:blue">latest</span></td></tr>
+<tr><td>3.8.1.0</td><td><span style="color:blue">latest</span></td></tr>
-<tr><td>3.8.1.0</td><td></td></tr>
 <tr><td>3.6.2.0</td><td><span style="color:green">recommended</span></td></tr>
 <tr><td>3.6.0.0</td><td></td></tr>
 <tr><td>3.4.1.0</td><td></td></tr>
@@ -166,9 +159,7 @@ GHCup supports the following tools, which are also known as the **Haskell Toolch
 <table>
 <thead><tr><th>HLS Version</th><th>Tags</th></tr></thead>
 <tbody>
-<tr><td>1.9.1.0</td><td><span style="color:blue">latest</span></td></tr>
+<tr><td>1.8.0.0</td><td><span style="color:blue">latest</span>, <span style="color:green">recommended</span></td></tr>
-<tr><td>1.9.0.0</td><td><span style="color:green">recommended</span></td></tr>
-<tr><td>1.8.0.0</td><td></td></tr>
 <tr><td>1.7.0.0</td><td></td></tr>
 <tr><td>1.6.1.0</td><td></td></tr>
 <tr><td>1.6.0.0</td><td></td></tr>
@@ -186,8 +177,7 @@ GHCup supports the following tools, which are also known as the **Haskell Toolch
 <table>
 <thead><tr><th>Stack Version</th><th>Tags</th></tr></thead>
 <tbody>
-<tr><td>2.9.3</td><td><span style="color:blue">latest</span>, <span style="color:green">recommended</span></td></tr>
+<tr><td>2.9.1</td><td><span style="color:blue">latest</span>, <span style="color:green">recommended</span></td></tr>
-<tr><td>2.9.1</td><td></td></tr>
 <tr><td>2.7.5</td><td></td></tr>
 <tr><td>2.7.3</td><td></td></tr>
 <tr><td>2.7.1</td><td></td></tr>
@@ -241,9 +231,8 @@ There are various issues with GHC itself.
 
 ### FreeBSD
 
-Lacks some upstream bindists and may need compat libs (such as `misc/compat12x`).
+Lacks some upstream bindists and may need compat libs, since most bindists are built on FreeBSD-12.
 HLS bindists are experimental.
-Only latest FreeBSD is generally supported.
 
 ### Linux ARMv7/AARCH64
 
@@ -256,7 +245,7 @@ Lower availability of bindists. Stack and HLS binaries are experimental.
 Download the binary for your platform at [https://downloads.haskell.org/~ghcup/](https://downloads.haskell.org/~ghcup/)
 and place it into your `PATH` anywhere.
 
-If you want to GPG verify the binaries, import the following keys first: `7D1E8AFD1D4A16D71FADA2F2CCC85C0E40C06A8C` and `FE5AB6C91FEA597C3B31180B73EDE9E8CFBAEF01`.
+If you want to GPG verify the binaries, import the following keys first: `7784930957807690A66EBDBE3786C5262ECB4A3F` and `FE5AB6C91FEA597C3B31180B73EDE9E8CFBAEF01`.
 
 Then adjust your `PATH` in `~/.bashrc` (or similar, depending on your shell) like so:
 
@@ -318,24 +307,6 @@ export PATH="$HOME/.cabal/bin:$HOME/.ghcup/bin:$PATH"
 
 All set. You can run `cabal init` now in an empty directory to start a project.
 
-## Esoteric distros
-
-### Void Linux
-
-Since void linux can be installed with glibc and musl, it's hard to support correctly with ghcup.
-One way to make ghcup work on **Void Linux musl** is to follow the [Overriding distro detection](../guide/#overriding-distro-detection)
-section and tell it to consider Alpine bindists only. E.g.:
-
-```sh
-curl --proto '=https' --tlsv1.2 -sSf https://get-ghcup.haskell.org | BOOTSTRAP_HASKELL_MINIMAL=1 sh
-source ~/.ghcup/env
-ghcup config set platform-override '{ "arch": "A_64", "platform": { "contents": "Alpine", "tag": "Linux" }, "version": "3.17" }'
-ghcup install cabal --set latest
-ghcup install ghc --set latest
-ghcup install stack --set latest
-ghcup install hls --set latest
-```
-
 ## Vim integration
 
 See [ghcup.vim](https://github.com/hasufell/ghcup.vim).

docs/steps.md

@@ -328,7 +328,7 @@ see the [Cabal user guide](https://cabal.readthedocs.io/en/stable/getting-starte
 <a href="https://hackage.haskell.org/" class="btn btn-primary" role="button">Discover Haskell packages</a>
 <a href="https://hackage.haskell.org/package/base" class="btn btn-primary" role="button">The standard library</a>
 <a href="https://haskell-language-server.readthedocs.io/en/stable/installation.html" class="btn btn-primary" role="button">Editor setup with HLS</a>
-<a href="https://play.haskell.org/" class="btn btn-primary" role="button">Online playground</a>
+<a href="https://play-haskell.tomsmeding.com/play" class="btn btn-primary" role="button">Online playground</a>
 </div>
 
 ## How to learn Haskell proper

ghcup.cabal

@@ -1,6 +1,6 @@
 cabal-version:      2.4
 name:               ghcup
-version:            0.1.19.5
+version:            0.1.19.2
 license:            LGPL-3.0-only
 license-file:       LICENSE
 copyright:          Julian Ospald 2020
@@ -137,7 +137,7 @@ library
     , pretty-terminal       ^>=0.1.0.0
     , regex-posix           ^>=0.96
     , resourcet             ^>=1.2.2
-    , retry                 ^>=0.8.1.2 || ^>=0.9
+    , retry                 ^>=0.8.1.2
     , safe                  ^>=0.3.18
     , safe-exceptions       ^>=0.1
     , split                 ^>=0.2.3.4
@@ -146,7 +146,7 @@ library
     , template-haskell      >=2.7        && <2.20
     , temporary             ^>=1.3
     , text                  ^>=2.0
-    , time                  ^>=1.9.3 || ^>=1.10 || ^>=1.11
+    , time                  ^>=1.9.3
     , transformers          ^>=0.5
     , unliftio-core         ^>=0.2.0.1
     , unordered-containers  ^>=0.2.10.0
@@ -269,7 +269,6 @@ executable ghcup
     , template-haskell       >=2.7      && <2.20
     , temporary              ^>=1.3
     , text                   ^>=2.0
-    , time                   ^>=1.9.3 || ^>=1.10 || ^>=1.11
     , unordered-containers   ^>=0.2
     , uri-bytestring         ^>=0.3.2.2
     , utf8-string            ^>=1.0
@@ -336,7 +335,6 @@ test-suite ghcup-test
     , QuickCheck                ^>=2.14.1
     , quickcheck-arbitrary-adt  ^>=0.3.1.0
     , streamly                  ^>=0.8.2
-    , time                      ^>=1.9.3 || ^>=1.10 || ^>=1.11
     , text                      ^>=2.0
     , uri-bytestring            ^>=0.3.2.2
     , versions                  >=4.0.1   && <5.1

lib/GHCup.hs

@@ -134,24 +134,15 @@ rmTool :: ( MonadReader env m
           => ListResult
           -> Excepts '[NotInstalled, UninstallFailed] m ()
 rmTool ListResult {lVer, lTool, lCross} = do
-  let printRmTool = logInfo $ "removing " <> T.pack (show lTool) <> " version " <> prettyVer lVer
+  logInfo $ "removing " <> T.pack (show lTool) <> " version " <> prettyVer lVer
   case lTool of
-    GHC -> do
+    GHC ->
       let ghcTargetVersion = GHCTargetVersion lCross lVer
-      logInfo $ "removing " <> T.pack (show lTool) <> " version " <> tVerToText ghcTargetVersion
+      in rmGHCVer ghcTargetVersion
-      rmGHCVer ghcTargetVersion
+    HLS -> rmHLSVer lVer
-    HLS -> do
+    Cabal -> liftE $ rmCabalVer lVer
-      printRmTool
+    Stack -> liftE $ rmStackVer lVer
-      rmHLSVer lVer
+    GHCup -> lift rmGhcup
-    Cabal -> do
-      printRmTool
-      liftE $ rmCabalVer lVer
-    Stack -> do
-      printRmTool
-      liftE $ rmStackVer lVer
-    GHCup -> do
-      printRmTool
-      lift rmGhcup
 
 
 rmGhcupDirs :: ( MonadReader env m
@@ -312,7 +303,7 @@ upgradeGHCup mtarget force' fatal = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
 
   lift $ logInfo "Upgrading GHCup..."
-  let latestVer = _tvVersion $ fst (fromJust (getLatest dls GHCup))
+  let latestVer = fst (fromJust (getLatest dls GHCup))
   (Just ghcupPVPVer) <- pure $ pvpToVersion ghcUpVer ""
   when (not force' && (latestVer <= ghcupPVPVer)) $ throwE NoUpdate
   dli   <- liftE $ getDownloadInfo GHCup latestVer
@@ -501,7 +492,7 @@ rmOldGHC :: ( MonadReader env m
          => Excepts '[NotInstalled, UninstallFailed] m ()
 rmOldGHC = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
-  let oldGHCs = toListOf (ix GHC % getTagged Old % to fst) dls
+  let oldGHCs = mkTVer <$> toListOf (ix GHC % getTagged Old % to fst) dls
   ghcs <- lift $ fmap rights getInstalledGHCs
   forM_ ghcs $ \ghc -> when (ghc `elem` oldGHCs) $ rmGHCVer ghc
 

lib/GHCup/Cabal.hs

@@ -38,7 +38,6 @@ import           Control.Monad.Trans.Resource
                                          hiding ( throwM )
 import           Data.Either
 import           Data.List
-import           Data.Ord
 import           Data.Maybe
 import           Data.Versions                hiding ( patch )
 import           Haskus.Utils.Variant.Excepts
@@ -281,6 +280,6 @@ rmCabalVer ver = do
 
   when (Just ver == cSet) $ do
     cVers <- lift $ fmap rights getInstalledCabals
-    case headMay . sortBy (comparing Down) $ cVers of
+    case headMay . reverse . sort $ cVers of
       Just latestver -> setCabal latestver
       Nothing        -> lift $ rmLink (binDir </> "cabal" <> exeExt)

lib/GHCup/Download.hs

@@ -87,8 +87,6 @@ import qualified Data.Text.IO                  as T
 import qualified Data.Text.Encoding            as E
 import qualified Data.Yaml.Aeson               as Y
 
-import qualified UnliftIO.Async                as Async
-
 
 
 
@@ -113,7 +111,6 @@ getDownloadsF :: ( FromJSONKey Tool
                  , MonadThrow m
                  , MonadFail m
                  , MonadMask m
-                 , MonadUnliftIO m
                  )
               => Excepts
                    '[DigestError, ContentLengthError, GPGError, JSONError , DownloadFailed , FileDoesNotExistError]
@@ -124,12 +121,12 @@ getDownloadsF = do
   case urlSource of
     GHCupURL -> liftE $ getBase ghcupURL
     (OwnSource exts) -> do
-      ext  <- Async.mapConcurrently (either pure (liftE . getBase)) exts
+      ext  <- liftE $ mapM (either pure getBase) exts
       mergeGhcupInfo ext
     (OwnSpec av) -> pure av
     (AddSource exts) -> do
       base <- liftE $ getBase ghcupURL
-      ext  <- Async.mapConcurrently (either pure (liftE . getBase)) exts
+      ext  <- liftE $ mapM (either pure getBase) exts
       mergeGhcupInfo (base:ext)
 
  where
@@ -274,6 +271,7 @@ getBase uri = do
 
       pure f
 
+
 getDownloadInfo :: ( MonadReader env m
                    , HasPlatformReq env
                    , HasGHCupInfo env
@@ -285,21 +283,8 @@ getDownloadInfo :: ( MonadReader env m
                      '[NoDownload]
                      m
                      DownloadInfo
-getDownloadInfo t v = getDownloadInfo' t (mkTVer v)
+getDownloadInfo t v = do
-
+  (PlatformRequest a p mv) <- lift getPlatformReq
-getDownloadInfo' :: ( MonadReader env m
-                    , HasPlatformReq env
-                    , HasGHCupInfo env
-                    )
-                 => Tool
-                 -> GHCTargetVersion
-                 -- ^ tool version
-                 -> Excepts
-                      '[NoDownload]
-                      m
-                      DownloadInfo
-getDownloadInfo' t v = do
-  pfreq@(PlatformRequest a p mv) <- lift getPlatformReq
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
 
   let distro_preview f g =
@@ -320,7 +305,7 @@ getDownloadInfo' t v = do
       without_distro     = distro_preview (set _Linux UnknownLinux) (const Nothing)
 
   maybe
-    (throwE $ NoDownload v t (Just pfreq))
+    (throwE NoDownload)
     pure
     (case p of
       -- non-musl won't work on alpine
@@ -648,9 +633,7 @@ downloadCached dli mfn = do
     True -> downloadCached' dli mfn Nothing
     False -> do
       tmp <- lift withGHCupTmpDir
-      liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) (_dlCSize dli) (fromGHCupPath tmp) outputFileName False
+      liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) (_dlCSize dli) (fromGHCupPath tmp) mfn False
- where
-  outputFileName = mfn <|> _dlOutput dli
 
 
 downloadCached' :: ( MonadReader env m
@@ -669,7 +652,7 @@ downloadCached' :: ( MonadReader env m
 downloadCached' dli mfn mDestDir = do
   Dirs { cacheDir } <- lift getDirs
   let destDir = fromMaybe (fromGHCupPath cacheDir) mDestDir
-  let fn = fromMaybe ((T.unpack . decUTF8Safe) $ urlBaseName $ view (dlUri % pathL') dli) outputFileName
+  let fn = fromMaybe ((T.unpack . decUTF8Safe) $ urlBaseName $ view (dlUri % pathL') dli) mfn
   let cachfile = destDir </> fn
   fileExists <- liftIO $ doesFileExist cachfile
   if
@@ -677,9 +660,7 @@ downloadCached' dli mfn mDestDir = do
       forM_ (view dlCSize dli) $ \s -> liftE $ checkCSize s cachfile
       liftE $ checkDigest (view dlHash dli) cachfile
       pure cachfile
-    | otherwise -> liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) (_dlCSize dli) destDir outputFileName False
+    | otherwise -> liftE $ download (_dlUri dli) Nothing (Just (_dlHash dli)) (_dlCSize dli) destDir mfn False
- where
-  outputFileName = mfn <|> _dlOutput dli
 
 
 

lib/GHCup/Errors.hs

@@ -38,7 +38,6 @@ import qualified Data.Text                     as T
 import qualified Data.Text.Encoding            as E
 import qualified Data.Text.Encoding.Error      as E
 import           Data.Data (Proxy(..))
-import Data.Time (Day)
 
 
 
@@ -60,7 +59,6 @@ allHFError = unlines allErrors
     , let proxy = Proxy :: Proxy CopyError in format proxy
     , let proxy = Proxy :: Proxy MergeFileTreeError in format proxy
     , let proxy = Proxy :: Proxy TagNotFound in format proxy
-    , let proxy = Proxy :: Proxy DayNotFound in format proxy
     , let proxy = Proxy :: Proxy NextVerNotFound in format proxy
     , let proxy = Proxy :: Proxy AlreadyInstalled in format proxy
     , let proxy = Proxy :: Proxy DirNotEmpty in format proxy
@@ -206,26 +204,12 @@ instance HFErrorProject NoCompatiblePlatform where
   eDesc _ = "No compatible platform could be found"
 
 -- | Unable to find a download for the requested version/distro.
-data NoDownload = NoDownload GHCTargetVersion Tool (Maybe PlatformRequest)
+data NoDownload = NoDownload
-                | NoDownload' GlobalTool
   deriving Show
 
 instance Pretty NoDownload where
-  pPrint (NoDownload tver@(GHCTargetVersion mtarget vv) tool mpfreq)
+  pPrint NoDownload =
-    | (Just target) <- mtarget
+    text (eDesc (Proxy :: Proxy NoDownload))
-    , target `elem` (T.pack . prettyShow <$> enumFromTo (minBound :: Tool) (maxBound :: Tool))
-    = text $ "Unable to find a download for "
-             <> show tool
-             <> " version '"
-             <> T.unpack (tVerToText tver)
-             <> maybe "'\n" (\pfreq -> "' on detected platform " <> pfReqToString pfreq <> "\n") mpfreq
-             <> "Perhaps you meant: 'ghcup <command> "
-             <> T.unpack target
-             <> " "
-             <> T.unpack (prettyVer vv)
-             <> "'"
-    | otherwise = text $ "Unable to find a download for " <> T.unpack (tVerToText tver)
-  pPrint (NoDownload' globalTool) = text $ "Unable to find a download for " <> prettyShow globalTool
 
 instance HFErrorProject NoDownload where
   eBase _ = 10
@@ -327,21 +311,6 @@ instance HFErrorProject TagNotFound where
   eBase _ = 90
   eDesc _ = "Unable to find a tag of a tool"
 
--- | Unable to find a release day of a tool
-data DayNotFound = DayNotFound Day Tool (Maybe Day)
-  deriving Show
-
-instance Pretty DayNotFound where
-  pPrint (DayNotFound day tool Nothing) =
-    text "Unable to find release date" <+> text (show day) <+> text "of tool" <+> pPrint tool
-  pPrint (DayNotFound day tool (Just alternateDay)) =
-    text "Unable to find release date" <+> text (show day) <+> text "of tool" <+> pPrint tool <+>
-      text "but found an alternative date" <+> text (show alternateDay)
-
-instance HFErrorProject DayNotFound where
-  eBase _ = 95
-  eDesc _ = "Unable to find a release date of a tool"
-
 -- | Unable to find the next version of a tool (the one after the currently
 -- set one).
 data NextVerNotFound = NextVerNotFound Tool
@@ -430,8 +399,6 @@ instance HFErrorProject JSONError where
   eBase _ = 160
   eDesc _ = "JSON decoding failed"
 
-instance Exception JSONError
-
 -- | A file that is supposed to exist does not exist
 -- (e.g. when we use file scheme to "download" something).
 data FileDoesNotExistError = FileDoesNotExistError FilePath
@@ -445,8 +412,6 @@ instance HFErrorProject FileDoesNotExistError where
   eBase _ = 170
   eDesc _ = "A file that is supposed to exist does not exist (oops)"
 
-instance Exception FileDoesNotExistError
-
 -- | The file already exists
 -- (e.g. when we use isolated installs with the same path).
 -- (e.g. This is done to prevent any overwriting)
@@ -486,8 +451,6 @@ instance HFErrorProject DigestError where
   eBase _ = 200
   eDesc _ = "File digest verification failed"
 
-instance Exception DigestError
-
 -- | File PGP verification failed.
 data GPGError = forall xs . (ToVariantMaybe DownloadFailed xs, PopVariant DownloadFailed xs, Show (V xs), Pretty (V xs)) => GPGError (V xs)
 
@@ -500,8 +463,6 @@ instance HFErrorProject GPGError where
   eBase _ = 210
   eDesc _ = "File PGP verification failed"
 
-instance Exception GPGError
-
 -- | Unexpected HTTP status.
 data HTTPStatusError = HTTPStatusError Int (M.Map (CI ByteString) ByteString)
   deriving Show
@@ -715,8 +676,6 @@ instance HFErrorProject DownloadFailed where
   eNum (DownloadFailed xs) = 5000 + eNum xs
   eDesc _ = "A download failed."
 
-instance Exception DownloadFailed
-
 data InstallSetError = forall xs1 xs2 . (Show (V xs1), Pretty (V xs1), HFErrorProject (V xs1), Show (V xs2), Pretty (V xs2), HFErrorProject (V xs2)) => InstallSetError (V xs1) (V xs2)
 
 instance Pretty InstallSetError where

lib/GHCup/GHC.hs

@@ -80,9 +80,9 @@ import qualified Data.Text.Encoding            as E
 import qualified Text.Megaparsec               as MP
 
 
-data GHCVer = SourceDist Version
+data GHCVer v = SourceDist v
-            | GitDist GitBranch
+              | GitDist GitBranch
-            | RemoteDist URI
+              | RemoteDist URI
 
 
 
@@ -105,7 +105,7 @@ testGHCVer :: ( MonadFail m
               , MonadIO m
               , MonadUnliftIO m
               )
-           => GHCTargetVersion
+           => Version
            -> [T.Text]
            -> Excepts
                 '[ DigestError
@@ -125,7 +125,7 @@ testGHCVer ver addMakeArgs = do
 
   dlInfo <-
     preview (ix GHC % ix ver % viTestDL % _Just) dls
-      ?? NoDownload ver GHC Nothing
+      ?? NoDownload
 
   liftE $ testGHCBindist dlInfo ver addMakeArgs
 
@@ -145,7 +145,7 @@ testGHCBindist :: ( MonadFail m
                   , MonadUnliftIO m
                   )
                => DownloadInfo
-               -> GHCTargetVersion
+               -> Version
                -> [T.Text]
                -> Excepts
                     '[ DigestError
@@ -182,7 +182,7 @@ testPackedGHC :: ( MonadMask m
                  )
               => FilePath          -- ^ Path to the packed GHC bindist
               -> Maybe TarDir      -- ^ Subdir of the archive
-              -> GHCTargetVersion  -- ^ The GHC version
+              -> Version           -- ^ The GHC version
               -> [T.Text]          -- ^ additional make args
               -> Excepts
                    '[ ArchiveResult, UnknownArchive, TarDirDoesNotExist, TestFailed ] m ()
@@ -208,21 +208,19 @@ testUnpackedGHC :: ( MonadReader env m
                    , MonadIO m
                    )
                 => GHCupPath         -- ^ Path to the unpacked GHC bindist (where the make file resides)
-                -> GHCTargetVersion  -- ^ The GHC version
+                -> Version           -- ^ The GHC version
                 -> [T.Text]          -- ^ additional configure args for bindist
                 -> Excepts '[ProcessError] m ()
-testUnpackedGHC path tver addMakeArgs = do
+testUnpackedGHC path ver addMakeArgs = do
-  lift $ logInfo $ "Testing GHC version " <> tVerToText tver <> "!"
+  lift $ logInfo $ "Testing GHC version " <> prettyVer ver <> "!"
-  ghcDir <- lift $ ghcupGHCDir tver
+  ghcDir <- lift $ ghcupGHCDir (mkTVer ver)
   let ghcBinDir = fromGHCupPath ghcDir </> "bin"
   env <- liftIO $ addToPath ghcBinDir False
 
   lEM $ make' (fmap T.unpack addMakeArgs)
               (Just $ fromGHCupPath path)
               "ghc-test"
-              (Just $ ("STAGE1_GHC", maybe "" (T.unpack . (<> "-")) (_tvTarget tver)
+              (Just $ ("STAGE1_GHC", "ghc-" <> T.unpack (prettyVer ver)) : env)
-                                     <> "ghc-"
-                                     <> T.unpack (prettyVer $ _tvVersion tver)) : env)
   pure ()
 
 
@@ -245,7 +243,7 @@ fetchGHCSrc :: ( MonadFail m
                , MonadIO m
                , MonadUnliftIO m
                )
-            => GHCTargetVersion
+            => Version
             -> Maybe FilePath
             -> Excepts
                  '[ DigestError
@@ -260,7 +258,7 @@ fetchGHCSrc v mfp = do
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
   dlInfo <-
     preview (ix GHC % ix v % viSourceDL % _Just) dls
-      ?? NoDownload v GHC Nothing
+      ?? NoDownload
   liftE $ downloadCached' dlInfo Nothing mfp
 
 
@@ -285,7 +283,7 @@ installGHCBindist :: ( MonadFail m
                      , MonadUnliftIO m
                      )
                   => DownloadInfo    -- ^ where/how to download
-                  -> GHCTargetVersion -- ^ the version to install
+                  -> Version         -- ^ the version to install
                   -> InstallDir
                   -> Bool            -- ^ Force install
                   -> [T.Text]        -- ^ additional configure args for bindist
@@ -308,8 +306,10 @@ installGHCBindist :: ( MonadFail m
                         ]
                        m
                        ()
-installGHCBindist dlinfo tver installDir forceInstall addConfArgs = do
+installGHCBindist dlinfo ver installDir forceInstall addConfArgs = do
-  lift $ logDebug $ "Requested to install GHC with " <> tVerToText tver
+  let tver = mkTVer ver
+
+  lift $ logDebug $ "Requested to install GHC with " <> prettyVer ver
 
   regularGHCInstalled <- lift $ ghcInstalled tver
 
@@ -317,7 +317,7 @@ installGHCBindist dlinfo tver installDir forceInstall addConfArgs = do
     | not forceInstall
     , regularGHCInstalled
     , GHCupInternal <- installDir -> do
-        throwE $ AlreadyInstalled GHC (_tvVersion tver)
+        throwE $ AlreadyInstalled GHC ver
 
     | forceInstall
     , regularGHCInstalled
@@ -336,12 +336,12 @@ installGHCBindist dlinfo tver installDir forceInstall addConfArgs = do
   case installDir of
     IsolateDir isoDir -> do                        -- isolated install
       lift $ logInfo $ "isolated installing GHC to " <> T.pack isoDir
-      liftE $ installPackedGHC dl (view dlSubdir dlinfo) (IsolateDirResolved isoDir) tver forceInstall addConfArgs
+      liftE $ installPackedGHC dl (view dlSubdir dlinfo) (IsolateDirResolved isoDir) ver forceInstall addConfArgs
     GHCupInternal -> do                            -- regular install
       -- prepare paths
       ghcdir <- lift $ ghcupGHCDir tver
 
-      liftE $ installPackedGHC dl (view dlSubdir dlinfo) (GHCupDir ghcdir) tver forceInstall addConfArgs
+      liftE $ installPackedGHC dl (view dlSubdir dlinfo) (GHCupDir ghcdir) ver forceInstall addConfArgs
 
       -- make symlinks & stuff when regular install,
       liftE $ postGHCInstall tver
@@ -375,7 +375,7 @@ installPackedGHC :: ( MonadMask m
                  => FilePath          -- ^ Path to the packed GHC bindist
                  -> Maybe TarDir      -- ^ Subdir of the archive
                  -> InstallDirResolved
-                 -> GHCTargetVersion  -- ^ The GHC version
+                 -> Version           -- ^ The GHC version
                  -> Bool              -- ^ Force install
                  -> [T.Text]          -- ^ additional configure args for bindist
                  -> Excepts
@@ -423,22 +423,26 @@ installUnpackedGHC :: ( MonadReader env m
                       )
                    => GHCupPath           -- ^ Path to the unpacked GHC bindist (where the configure script resides)
                    -> InstallDirResolved  -- ^ Path to install to
-                   -> GHCTargetVersion    -- ^ The GHC version
+                   -> Version             -- ^ The GHC version
                    -> Bool                -- ^ Force install
                    -> [T.Text]          -- ^ additional configure args for bindist
                    -> Excepts '[ProcessError, MergeFileTreeError] m ()
-installUnpackedGHC path inst tver forceInstall addConfArgs
+installUnpackedGHC path inst ver forceInstall addConfArgs
   | isWindows = do
       lift $ logInfo "Installing GHC (this may take a while)"
       -- Windows bindists are relocatable and don't need
       -- to run configure.
       -- We also must make sure to preserve mtime to not confuse ghc-pkg.
-      liftE $ mergeGHCFileTree path inst tver forceInstall
+      liftE $ mergeFileTree path inst GHC (mkTVer ver) $ \source dest -> do
+        mtime <- liftIO $ ifM (pathIsSymbolicLink source) (pure Nothing) (Just <$> getModificationTime source)
+        when forceInstall $ hideError doesNotExistErrorType $ hideError InappropriateType $ recycleFile dest
+        liftIO $ moveFilePortable source dest
+        forM_ mtime $ liftIO . setModificationTime dest
   | otherwise = do
       PlatformRequest {..} <- lift getPlatformReq
 
       let ldOverride
-           | _tvVersion tver >= [vver|8.2.2|]
+           | ver >= [vver|8.2.2|]
            , _rPlatform `elem` [Linux Alpine, Darwin]
            = ["--disable-ld-override"]
            | otherwise
@@ -447,7 +451,7 @@ installUnpackedGHC path inst tver forceInstall addConfArgs
       lift $ logInfo "Installing GHC (this may take a while)"
       lEM $ execLogged "sh"
                        ("./configure" : ("--prefix=" <> fromInstallDir inst)
-                        : (maybe mempty (\x -> ["--target=" <> T.unpack x]) (_tvTarget tver) <> ldOverride <> (T.unpack <$> addConfArgs))
+                        : (ldOverride <> (T.unpack <$> addConfArgs))
                        )
                        (Just $ fromGHCupPath path)
                        "ghc-configure"
@@ -455,44 +459,17 @@ installUnpackedGHC path inst tver forceInstall addConfArgs
       tmpInstallDest <- lift withGHCupTmpDir
       lEM $ make ["DESTDIR=" <> fromGHCupPath tmpInstallDest, "install"] (Just $ fromGHCupPath path)
       liftE $ catchWarn $ lEM @_ @'[ProcessError] $ darwinNotarization _rPlatform (fromGHCupPath tmpInstallDest)
-      liftE $ mergeGHCFileTree (tmpInstallDest `appendGHCupPath` dropDrive (fromInstallDir inst)) inst tver forceInstall
+      liftE $ mergeFileTree (tmpInstallDest `appendGHCupPath` dropDrive (fromInstallDir inst))
-      pure ()
-
-
-mergeGHCFileTree :: ( MonadReader env m
-                    , HasPlatformReq env
-                    , HasDirs env
-                    , HasSettings env
-                    , MonadThrow m
-                    , HasLog env
-                    , MonadIO m
-                    , MonadUnliftIO m
-                    , MonadMask m
-                    , MonadResource m
-                    , MonadFail m
-                    )
-                 => GHCupPath           -- ^ Path to the root of the tree
-                 -> InstallDirResolved  -- ^ Path to install to
-                 -> GHCTargetVersion    -- ^ The GHC version
-                 -> Bool                -- ^ Force install
-                 -> Excepts '[MergeFileTreeError] m ()
-mergeGHCFileTree root inst tver forceInstall
-  | isWindows = do
-      liftE $ mergeFileTree root inst GHC tver $ \source dest -> do
-        mtime <- liftIO $ ifM (pathIsSymbolicLink source) (pure Nothing) (Just <$> getModificationTime source)
-        when forceInstall $ hideError doesNotExistErrorType $ hideError InappropriateType $ recycleFile dest
-        liftIO $ moveFilePortable source dest
-        forM_ mtime $ liftIO . setModificationTime dest
-  | otherwise = do
-      liftE $ mergeFileTree root
         inst
         GHC
-        tver
+        (mkTVer ver)
         (\f t -> liftIO $ do
             mtime <- ifM (pathIsSymbolicLink f) (pure Nothing) (Just <$> getModificationTime f)
             install f t (not forceInstall)
             forM_ mtime $ setModificationTime t)
 
+      pure ()
+
 
 -- | Installs GHC into @~\/.ghcup\/ghc/\<ver\>@ and places the
 -- following symlinks in @~\/.ghcup\/bin@:
@@ -512,7 +489,7 @@ installGHCBin :: ( MonadFail m
                  , MonadIO m
                  , MonadUnliftIO m
                  )
-              => GHCTargetVersion -- ^ the version to install
+              => Version         -- ^ the version to install
               -> InstallDir
               -> Bool            -- ^ force install
               -> [T.Text]        -- ^ additional configure args for bindist
@@ -535,9 +512,9 @@ installGHCBin :: ( MonadFail m
                     ]
                    m
                    ()
-installGHCBin tver installDir forceInstall addConfArgs = do
+installGHCBin ver installDir forceInstall addConfArgs = do
-  dlinfo <- liftE $ getDownloadInfo' GHC tver
+  dlinfo <- liftE $ getDownloadInfo GHC ver
-  liftE $ installGHCBindist dlinfo tver installDir forceInstall addConfArgs
+  liftE $ installGHCBindist dlinfo ver installDir forceInstall addConfArgs
 
 
 
@@ -731,7 +708,7 @@ rmGHCVer ver = do
     Just files -> do
       lift $ logInfo $ "Removing files safely from: " <> T.pack dir
       forM_ files (lift . hideError NoSuchThing . recycleFile . (\f -> dir </> dropDrive f))
-      hideError UnsatisfiedConstraints $ removeEmptyDirsRecursive dir
+      removeEmptyDirsRecursive dir
       survivors <- liftIO $ hideErrorDef [doesNotExistErrorType] [] $ listDirectory dir
       f <- recordedInstallationFile GHC ver
       lift $ recycleFile f
@@ -778,8 +755,7 @@ compileGHC :: ( MonadMask m
               , MonadUnliftIO m
               , MonadFail m
               )
-           => GHCVer
+           => GHCVer GHCTargetVersion
-           -> Maybe Text               -- ^ cross target
            -> Maybe Version            -- ^ overwrite version
            -> Either Version FilePath  -- ^ version to bootstrap with
            -> Maybe Int                -- ^ jobs
@@ -787,7 +763,7 @@ compileGHC :: ( MonadMask m
            -> Maybe (Either FilePath [URI])  -- ^ patches
            -> [Text]                   -- ^ additional args to ./configure
            -> Maybe String             -- ^ build flavour
-           -> Maybe BuildSystem
+           -> Bool
            -> InstallDir
            -> Excepts
                 '[ AlreadyInstalled
@@ -816,21 +792,20 @@ compileGHC :: ( MonadMask m
                  ]
                 m
                 GHCTargetVersion
-compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs buildFlavour buildSystem installDir
+compileGHC targetGhc ov bstrap jobs mbuildConfig patches aargs buildFlavour hadrian installDir
   = do
-    pfreq@PlatformRequest { .. } <- lift getPlatformReq
+    PlatformRequest { .. } <- lift getPlatformReq
     GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
 
     (workdir, tmpUnpack, tver) <- case targetGhc of
       -- unpack from version tarball
-      SourceDist ver -> do
+      SourceDist tver -> do
-        lift $ logDebug $ "Requested to compile: " <> prettyVer ver <> " with " <> either prettyVer T.pack bstrap
+        lift $ logDebug $ "Requested to compile: " <> tVerToText tver <> " with " <> either prettyVer T.pack bstrap
 
         -- download source tarball
-        let tver = mkTVer ver
         dlInfo <-
-          preview (ix GHC % ix tver % viSourceDL % _Just) dls
+          preview (ix GHC % ix (tver ^. tvVersion) % viSourceDL % _Just) dls
-            ?? NoDownload tver GHC (Just pfreq)
+            ?? NoDownload
         dl <- liftE $ downloadCached dlInfo Nothing
 
         -- unpack
@@ -843,7 +818,7 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
                          (view dlSubdir dlInfo)
         liftE $ applyAnyPatch patches (fromGHCupPath workdir)
 
-        pure (workdir, tmpUnpack, Just (GHCTargetVersion crossTarget ver))
+        pure (workdir, tmpUnpack, Just tver)
 
       RemoteDist uri -> do
         lift $ logDebug $ "Requested to compile (from uri): " <> T.pack (show uri)
@@ -867,7 +842,7 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
 
         let workdir = appendGHCupPath tmpUnpack (takeDirectory bf)
 
-        pure (workdir, tmpUnpack, GHCTargetVersion crossTarget <$> tver)
+        pure (workdir, tmpUnpack, mkTVer <$> tver)
 
       -- clone from git
       GitDist GitBranch{..} -> do
@@ -924,12 +899,12 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
 
           pure tver
 
-        pure (tmpUnpack, tmpUnpack, GHCTargetVersion crossTarget <$> tver)
+        pure (tmpUnpack, tmpUnpack, mkTVer <$> tver)
     -- the version that's installed may differ from the
     -- compiled version, so the user can overwrite it
-    installVer <- if | Just ov'   <- ov   -> pure (GHCTargetVersion crossTarget ov')
+    installVer <- if | Just ov'   <- ov   -> pure (mkTVer ov')
                      | Just tver' <- tver -> pure tver'
-                     | otherwise          -> fail "No GHC version given and couldn't detect version. Giving up..."
+                     | otherwise          -> fail "Newer GHCs don't support discovering the version in git. Complain to GHC devs: https://gitlab.haskell.org/ghc/ghc/-/issues/22322"
 
     alreadyInstalled <- lift $ ghcInstalled installVer
     alreadySet <- fmap (== Just installVer) $ lift $ ghcSet (_tvTarget installVer)
@@ -948,31 +923,16 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
       IsolateDir isoDir -> pure $ IsolateDirResolved isoDir
       GHCupInternal -> GHCupDir <$> lift (ghcupGHCDir installVer)
 
-    mBindist <- liftE $ runBuildAction
+    (mBindist, bmk) <- liftE $ runBuildAction
       tmpUnpack
       (do
-        -- prefer 'tver', because the real version carries out compatibility checks
+        b <- if hadrian
-        -- we don't want the user to do funny things with it
+             -- prefer 'tver', because the real version carries out compatibility checks
-        let doHadrian = compileHadrianBindist (fromMaybe installVer tver) (fromGHCupPath workdir) ghcdir
+             -- we don't want the user to do funny things with it
-            doMake    = compileMakeBindist (fromMaybe installVer tver) (fromGHCupPath workdir) ghcdir
+             then compileHadrianBindist (fromMaybe installVer tver) (fromGHCupPath workdir) ghcdir
-        case buildSystem of
+             else compileMakeBindist (fromMaybe installVer tver) (fromGHCupPath workdir) ghcdir
-          Just Hadrian -> do
+        bmk <- liftIO $ handleIO (\_ -> pure "") $ B.readFile (build_mk $ fromGHCupPath workdir)
-            lift $ logInfo "Requested to use Hadrian"
+        pure (b, bmk)
-            liftE doHadrian
-          Just Make -> do
-            lift $ logInfo "Requested to use Make"
-            doMake
-          Nothing -> do
-            supportsHadrian <- liftE $ catchE @HadrianNotFound @'[HadrianNotFound] @'[] (\_ -> return False)
-                                 $ fmap (const True)
-                                 $ findHadrianFile (fromGHCupPath workdir)
-            if supportsHadrian
-            then do
-              lift $ logInfo "Detected Hadrian"
-              liftE doHadrian
-            else do
-              lift $ logInfo "Detected Make"
-              doMake
       )
 
     case installDir of
@@ -988,10 +948,12 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
       liftE $ installPackedGHC bindist
                                (Just $ RegexDir "ghc-.*")
                                ghcdir
-                               installVer
+                               (installVer ^. tvVersion)
                                False       -- not a force install, since we already overwrite when compiling.
                                []
 
+    liftIO $ B.writeFile (fromInstallDir ghcdir </> ghcUpSrcBuiltFile) bmk
+
     case installDir of
       -- set and make symlinks for regular (non-isolated) installs
       GHCupInternal -> do
@@ -1014,29 +976,20 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
             => GHCupPath
             -> Excepts '[ProcessError, ParseError] m Version
   getGHCVer tmpUnpack = do
-    lEM $ execLogged "python3" ["./boot"] (Just $ fromGHCupPath tmpUnpack) "ghc-bootstrap" Nothing
+    lEM $ execWithGhcEnv "python3" ["./boot"] (Just $ fromGHCupPath tmpUnpack) "ghc-bootstrap"
-    lEM $ configureWithGhcBoot Nothing [] (Just $ fromGHCupPath tmpUnpack) "ghc-bootstrap"
+    lEM $ execWithGhcEnv "sh" ["./configure"] (Just $ fromGHCupPath tmpUnpack) "ghc-bootstrap"
-    let versionFile = fromGHCupPath tmpUnpack </> "VERSION"
+    CapturedProcess {..} <- lift $ makeOut
-    hasVersionFile <- liftIO $ doesFileExist versionFile
+      ["show!", "--quiet", "VALUE=ProjectVersion" ] (Just $ fromGHCupPath tmpUnpack)
-    if hasVersionFile
+    case _exitCode of
-    then do
+      ExitSuccess -> either (throwE . ParseError . show) pure . MP.parse ghcProjectVersion "" . T.pack . stripNewlineEnd . T.unpack . decUTF8Safe' $ _stdOut
-      lift $ logDebug "Detected VERSION file, trying to extract"
+      ExitFailure c -> throwE $ NonZeroExit c "make" ["show!", "--quiet", "VALUE=ProjectVersion" ]
-      contents <- liftIO $ readFile versionFile
-      either (throwE . ParseError . show) pure . MP.parse version' "" . T.pack . stripNewlineEnd $ contents
-    else do
-      lift $ logDebug "Didn't detect VERSION file, trying to extract via legacy 'make'"
-      CapturedProcess {..} <- lift $ makeOut
-        ["show!", "--quiet", "VALUE=ProjectVersion" ] (Just $ fromGHCupPath tmpUnpack)
-      case _exitCode of
-        ExitSuccess -> either (throwE . ParseError . show) pure . MP.parse ghcProjectVersion "" . T.pack . stripNewlineEnd . T.unpack . decUTF8Safe' $ _stdOut
-        ExitFailure c -> throwE $ NonZeroExit c "make" ["show!", "--quiet", "VALUE=ProjectVersion" ]
 
   defaultConf =
     let cross_mk = $(LitE . StringL <$> (qAddDependentFile "data/build_mk/cross" >> runIO (readFile "data/build_mk/cross")))
         default_mk = $(LitE . StringL <$> (qAddDependentFile "data/build_mk/default" >> runIO (readFile "data/build_mk/default")))
-    in case crossTarget of
+    in case targetGhc of
-         Just _ -> cross_mk
+         SourceDist (GHCTargetVersion (Just _) _) -> cross_mk
-         _      -> default_mk
+         _ -> default_mk
 
   compileHadrianBindist :: ( MonadReader env m
                            , HasDirs env
@@ -1062,17 +1015,18 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
                              m
                              (Maybe FilePath)  -- ^ output path of bindist, None for cross
   compileHadrianBindist tver workdir ghcdir = do
+    lEM $ execWithGhcEnv "python3" ["./boot"] (Just workdir) "ghc-bootstrap"
+
     liftE $ configureBindist tver workdir ghcdir
 
     lift $ logInfo "Building (this may take a while)..."
     hadrian_build <- liftE $ findHadrianFile workdir
-    lEM $ execLogged hadrian_build
+    lEM $ execWithGhcEnv hadrian_build
                           ( maybe [] (\j  -> ["-j" <> show j]         ) jobs
                          ++ maybe [] (\bf -> ["--flavour=" <> bf]) buildFlavour
                          ++ ["binary-dist"]
                           )
                           (Just workdir) "ghc-make"
-                          Nothing
     [tar] <- liftIO $ findFiles
       (workdir </> "_build" </> "bindist")
       (makeRegexOpts compExtended
@@ -1105,9 +1059,6 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
                         , HasLog env
                         , MonadIO m
                         , MonadFail m
-                        , MonadMask m
-                        , MonadUnliftIO m
-                        , MonadResource m
                         )
                      => GHCTargetVersion
                      -> FilePath
@@ -1119,7 +1070,6 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
                            , PatchFailed
                            , ProcessError
                            , NotFoundInPATH
-                           , MergeFileTreeError
                            , CopyError]
                           m
                        (Maybe FilePath)  -- ^ output path of bindist, None for cross
@@ -1141,9 +1091,7 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
 
     if | isCross tver -> do
           lift $ logInfo "Installing cross toolchain..."
-          tmpInstallDest <- lift withGHCupTmpDir
+          lEM $ make ["install"] (Just workdir)
-          lEM $ make ["DESTDIR=" <> fromGHCupPath tmpInstallDest, "install"] (Just workdir)
-          liftE $ mergeGHCFileTree (tmpInstallDest `appendGHCupPath` dropDrive (fromInstallDir ghcdir)) ghcdir tver True
           pure Nothing
        | otherwise -> do
           lift $ logInfo "Creating bindist..."
@@ -1216,8 +1164,8 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
     let lines' = fmap T.strip . T.lines $ decUTF8Safe c
 
    -- for cross, we need Stage1Only
-    case crossTarget of
+    case targetGhc of
-      Just _ -> when ("Stage1Only = YES" `notElem` lines') $ throwE
+      SourceDist (GHCTargetVersion (Just _) _) -> when ("Stage1Only = YES" `notElem` lines') $ throwE
         (InvalidBuildConfig
           [s|Cross compiling needs to be a Stage1 build, add "Stage1Only = YES" to your config!|]
         )
@@ -1261,50 +1209,64 @@ compileGHC targetGhc crossTarget ov bstrap jobs mbuildConfig patches aargs build
                         ()
   configureBindist tver workdir (fromInstallDir -> ghcdir) = do
     lift $ logInfo [s|configuring build|]
-    lEM $ configureWithGhcBoot (Just tver)
+
-      (maybe mempty
+    if | _tvVersion tver >= [vver|8.8.0|] -> do
-                (\x -> ["--target=" <> T.unpack x])
+          lEM $ execWithGhcEnv
-                (_tvTarget tver)
+            "sh"
-      ++ ["--prefix=" <> ghcdir]
+            ("./configure" :  maybe mempty
-      ++ (if isWindows then ["--enable-tarballs-autodownload"] else [])
+                      (\x -> ["--target=" <> T.unpack x])
-      ++ fmap T.unpack aargs
+                      (_tvTarget tver)
-      )
+            ++ ["--prefix=" <> ghcdir]
-      (Just workdir)
+            ++ (if isWindows then ["--enable-tarballs-autodownload"] else [])
-      "ghc-conf"
+            ++ fmap T.unpack aargs
+            )
+            (Just workdir)
+            "ghc-conf"
+       | otherwise -> do
+        lEM $ execLogged
+          "sh"
+          (  [ "./configure", "--with-ghc=" <> either id id bghc
+             ]
+          ++ maybe mempty
+                   (\x -> ["--target=" <> T.unpack x])
+                   (_tvTarget tver)
+          ++ ["--prefix=" <> ghcdir]
+          ++ (if isWindows then ["--enable-tarballs-autodownload"] else [])
+          ++ fmap T.unpack aargs
+          )
+          (Just workdir)
+          "ghc-conf"
+          Nothing
     pure ()
 
-  configureWithGhcBoot :: ( MonadReader env m
+  execWithGhcEnv :: ( MonadReader env m
-                          , HasSettings env
+                    , HasSettings env
-                          , HasDirs env
+                    , HasDirs env
-                          , HasLog env
+                    , HasLog env
-                          , MonadIO m
+                    , MonadIO m
-                          , MonadThrow m)
+                    , MonadThrow m)
-                       => Maybe GHCTargetVersion
+                 => FilePath         -- ^ thing to execute
-                       -> [String]         -- ^ args for configure
+                 -> [String]         -- ^ args for the thing
-                       -> Maybe FilePath   -- ^ optionally chdir into this
+                 -> Maybe FilePath   -- ^ optionally chdir into this
-                       -> FilePath         -- ^ log filename (opened in append mode)
+                 -> FilePath         -- ^ log filename (opened in append mode)
-                       -> m (Either ProcessError ())
+                 -> m (Either ProcessError ())
-  configureWithGhcBoot mtver args dir logf = do
+  execWithGhcEnv fp args dir logf = do
-    let execNew = execLogged
+    env <- ghcEnv
-                    "sh"
+    execLogged fp args dir logf (Just env)
-                    ("./configure" : ("GHC=" <> bghc) : args)
-                    dir
-                    logf
-                    Nothing
-        execOld = execLogged
-                   "sh"
-                   ("./configure" : ("--with-ghc=" <> bghc) : args)
-                   dir
-                   logf
-                   Nothing
-    if | Just tver <- mtver
-       , _tvVersion tver >= [vver|8.8.0|] -> execNew
-       | Nothing   <- mtver               -> execNew -- need some default for git checkouts where we don't know yet
-       | otherwise                        -> execOld
 
   bghc = case bstrap of
-           Right g    -> g
+           Right g    -> Right g
-           Left  bver -> "ghc-" <> (T.unpack . prettyVer $ bver) <> exeExt
+           Left  bver -> Left ("ghc-" <> (T.unpack . prettyVer $ bver) <> exeExt)
+
+  ghcEnv :: (MonadThrow m, MonadIO m) => m [(String, String)]
+  ghcEnv = do
+    cEnv <- liftIO getEnvironment
+    bghcPath <- case bghc of
+      Right ghc' -> pure ghc'
+      Left  bver -> do
+        spaths <- liftIO getSearchPath
+        throwMaybeM (NotFoundInPATH bver) $ liftIO (searchPath spaths bver)
+    pure (("GHC", bghcPath) : cEnv)
 
 
 

lib/GHCup/HLS.hs

@@ -43,7 +43,6 @@ import           Control.Monad.Trans.Resource
 import           Data.ByteString                ( ByteString )
 import           Data.Either
 import           Data.List
-import           Data.Ord
 import           Data.Maybe
 import           Data.String                    ( fromString )
 import           Data.Text                      ( Text )
@@ -354,7 +353,7 @@ compileHLS :: ( MonadMask m
                        , NotInstalled
                        ] m Version
 compileHLS targetHLS ghcs jobs ov installDir cabalProject cabalProjectLocal updateCabal patches cabalArgs = do
-  pfreq@PlatformRequest { .. } <- lift getPlatformReq
+  PlatformRequest { .. } <- lift getPlatformReq
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
   Dirs { .. } <- lift getDirs
 
@@ -369,8 +368,8 @@ compileHLS targetHLS ghcs jobs ov installDir cabalProject cabalProjectLocal upda
 
       -- download source tarball
       dlInfo <-
-        preview (ix HLS % ix (mkTVer tver) % viSourceDL % _Just) dls
+        preview (ix HLS % ix tver % viSourceDL % _Just) dls
-          ?? NoDownload (mkTVer tver) HLS (Just pfreq)
+          ?? NoDownload
       dl <- liftE $ downloadCached dlInfo Nothing
 
       -- unpack
@@ -705,7 +704,7 @@ rmHLSVer ver = do
   when (Just ver == isHlsSet) $ do
     -- set latest hls
     hlsVers <- lift $ fmap rights getInstalledHLSs
-    case headMay . sortBy (comparing Down) $ hlsVers of
+    case headMay . reverse . sort $ hlsVers of
       Just latestver -> liftE $ setHLS latestver SetHLSOnly Nothing
       Nothing        -> pure ()
 

lib/GHCup/List.hs

@@ -36,7 +36,6 @@ import           Data.Either
 import           Data.List
 import           Data.Maybe
 import           Data.Text                      ( Text )
-import           Data.Time.Calendar             ( Day )
 import           Data.Versions                hiding ( patch )
 import           Haskus.Utils.Variant.Excepts
 import           Optics
@@ -62,9 +61,9 @@ import qualified Data.Text                     as T
 
 
 -- | Filter data type for 'listVersions'.
-data ListCriteria = ListInstalled  Bool
+data ListCriteria = ListInstalled
-                  | ListSet        Bool
+                  | ListSet
-                  | ListAvailable  Bool
+                  | ListAvailable
                   deriving Show
 
 -- | A list result describes a single tool version
@@ -76,16 +75,16 @@ data ListResult = ListResult
   , lTag       :: [Tag]
   , lInstalled :: Bool
   , lSet       :: Bool -- ^ currently active version
+  , fromSrc    :: Bool -- ^ compiled from source
   , lStray     :: Bool -- ^ not in download info
   , lNoBindist :: Bool -- ^ whether the version is available for this platform/arch
   , hlsPowered :: Bool
-  , lReleaseDay :: Maybe Day
   }
   deriving (Eq, Ord, Show)
 
 
 -- | Extract all available tool versions and their tags.
-availableToolVersions :: GHCupDownloads -> Tool -> Map.Map GHCTargetVersion VersionInfo
+availableToolVersions :: GHCupDownloads -> Tool -> Map.Map Version VersionInfo
 availableToolVersions av tool = view
   (at tool % non Map.empty)
   av
@@ -94,22 +93,19 @@ availableToolVersions av tool = view
 -- | List all versions from the download info, as well as stray
 -- versions.
 listVersions :: ( MonadCatch m
-                             , HasLog env
+                , HasLog env
-                             , MonadThrow m
+                , MonadThrow m
-                             , HasLog env
+                , HasLog env
-                             , MonadIO m
+                , MonadIO m
-                             , MonadReader env m
+                , MonadReader env m
-                             , HasDirs env
+                , HasDirs env
-                             , HasPlatformReq env
+                , HasPlatformReq env
-                             , HasGHCupInfo env
+                , HasGHCupInfo env
-                             )
+                )
-                          => Maybe Tool
+             => Maybe Tool
-                          -> [ListCriteria]
+             -> Maybe ListCriteria
-                          -> Bool
+             -> m [ListResult]
-                          -> Bool
+listVersions lt' criteria = do
-                          -> (Maybe Day, Maybe Day)
-                          -> m [ListResult]
-listVersions lt' criteria hideOld showNightly days = do
   -- some annoying work to avoid too much repeated IO
   cSet <- cabalSet
   cabals <- getInstalledCabals
@@ -133,13 +129,13 @@ listVersions lt' criteria hideOld showNightly days = do
             slr <- strayGHCs avTools
             pure (sort (slr ++ lr))
           Cabal -> do
-            slr <- strayCabals (Map.mapKeys _tvVersion avTools) cSet cabals
+            slr <- strayCabals avTools cSet cabals
             pure (sort (slr ++ lr))
           HLS -> do
-            slr <- strayHLS (Map.mapKeys _tvVersion avTools) hlsSet' hlses
+            slr <- strayHLS avTools hlsSet' hlses
             pure (sort (slr ++ lr))
           Stack -> do
-            slr <- strayStacks (Map.mapKeys _tvVersion avTools) sSet stacks
+            slr <- strayStacks avTools sSet stacks
             pure (sort (slr ++ lr))
           GHCup -> do
             let cg = maybeToList $ currentGHCup avTools
@@ -158,28 +154,42 @@ listVersions lt' criteria hideOld showNightly days = do
                , HasLog env
                , MonadIO m
                )
-            => Map.Map GHCTargetVersion VersionInfo
+            => Map.Map Version VersionInfo
             -> m [ListResult]
   strayGHCs avTools = do
     ghcs <- getInstalledGHCs
     fmap catMaybes $ forM ghcs $ \case
-      Right tver@GHCTargetVersion{ .. } -> do
+      Right tver@GHCTargetVersion{ _tvTarget = Nothing, .. } -> do
-        case Map.lookup tver avTools of
+        case Map.lookup _tvVersion avTools of
           Just _  -> pure Nothing
           Nothing -> do
-            lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet _tvTarget
+            lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet Nothing
+            fromSrc <- ghcSrcInstalled tver
             hlsPowered <- fmap (elem _tvVersion) hlsGHCVersions
             pure $ Just $ ListResult
               { lTool      = GHC
               , lVer       = _tvVersion
-              , lCross     = _tvTarget
+              , lCross     = Nothing
               , lTag       = []
               , lInstalled = True
-              , lStray     = isNothing (Map.lookup tver avTools)
+             , lStray     = isNothing (Map.lookup _tvVersion avTools)
               , lNoBindist = False
-              , lReleaseDay = Nothing
               , ..
               }
+      Right tver@GHCTargetVersion{ .. } -> do
+        lSet    <- fmap (maybe False (\(GHCTargetVersion _ v ) -> v == _tvVersion)) $ ghcSet _tvTarget
+        fromSrc <- ghcSrcInstalled tver
+        hlsPowered <- fmap (elem _tvVersion) hlsGHCVersions
+        pure $ Just $ ListResult
+          { lTool      = GHC
+          , lVer       = _tvVersion
+          , lCross     = _tvTarget
+          , lTag       = []
+          , lInstalled = True
+          , lStray     = True -- NOTE: cross currently cannot be installed via bindist
+          , lNoBindist = False
+          , ..
+          }
       Left e -> do
         logWarn
           $ "Could not parse version of stray directory" <> T.pack e
@@ -211,8 +221,8 @@ listVersions lt' criteria hideOld showNightly days = do
               , lInstalled = True
               , lStray     = isNothing (Map.lookup ver avTools)
               , lNoBindist = False
+              , fromSrc    = False -- actually, we don't know :>
               , hlsPowered = False
-              , lReleaseDay = Nothing
               , ..
               }
       Left e -> do
@@ -245,8 +255,8 @@ listVersions lt' criteria hideOld showNightly days = do
               , lInstalled = True
               , lStray     = isNothing (Map.lookup ver avTools)
               , lNoBindist = False
+              , fromSrc    = False -- actually, we don't know :>
               , hlsPowered = False
-              , lReleaseDay = Nothing
               , ..
               }
       Left e -> do
@@ -280,8 +290,8 @@ listVersions lt' criteria hideOld showNightly days = do
               , lInstalled = True
               , lStray     = isNothing (Map.lookup ver avTools)
               , lNoBindist = False
+              , fromSrc    = False -- actually, we don't know :>
               , hlsPowered = False
-              , lReleaseDay = Nothing
               , ..
               }
       Left e -> do
@@ -289,24 +299,24 @@ listVersions lt' criteria hideOld showNightly days = do
           $ "Could not parse version of stray directory" <> T.pack e
         pure Nothing
 
-  currentGHCup :: Map.Map GHCTargetVersion VersionInfo -> Maybe ListResult
+  currentGHCup :: Map.Map Version VersionInfo -> Maybe ListResult
   currentGHCup av =
-    let currentVer = mkTVer $ fromJust $ pvpToVersion ghcUpVer ""
+    let currentVer = fromJust $ pvpToVersion ghcUpVer ""
         listVer    = Map.lookup currentVer av
         latestVer  = fst <$> headOf (getTagged Latest) av
         recommendedVer = fst <$> headOf (getTagged Latest) av
         isOld  = maybe True (> currentVer) latestVer && maybe True (> currentVer) recommendedVer
     in if | Map.member currentVer av -> Nothing
-          | otherwise -> Just $ ListResult { lVer    = _tvVersion currentVer
+          | otherwise -> Just $ ListResult { lVer    = currentVer
                                            , lTag    = maybe (if isOld then [Old] else []) _viTags listVer
                                            , lCross  = Nothing
                                            , lTool   = GHCup
+                                           , fromSrc = False
                                            , lStray  = isNothing listVer
                                            , lSet    = True
                                            , lInstalled = True
                                            , lNoBindist = False
                                            , hlsPowered = False
-                                           , lReleaseDay = Nothing
                                            }
 
   -- NOTE: this are not cross ones, because no bindists
@@ -325,41 +335,42 @@ listVersions lt' criteria hideOld showNightly days = do
                -> [Either FilePath Version]
                -> Maybe Version
                -> [Either FilePath Version]
-               -> (GHCTargetVersion, VersionInfo)
+               -> (Version, VersionInfo)
                -> m ListResult
-  toListResult t cSet cabals hlsSet' hlses stackSet' stacks (tver, VersionInfo{..}) = do
+  toListResult t cSet cabals hlsSet' hlses stackSet' stacks (v, _viTags -> tags) = do
-    let v = _tvVersion tver
     case t of
       GHC -> do
-        lNoBindist <- fmap (isLeft . veitherToEither) $ runE @'[NoDownload] $ getDownloadInfo' GHC tver
+        lNoBindist <- fmap (isLeft . veitherToEither) $ runE @'[NoDownload] $ getDownloadInfo GHC v
-        lSet       <- fmap (== Just tver) $ ghcSet (_tvTarget tver)
+        let tver = mkTVer v
+        lSet       <- fmap (maybe False (\(GHCTargetVersion _ v') -> v' == v)) $ ghcSet Nothing
         lInstalled <- ghcInstalled tver
-        hlsPowered <- fmap (elem tver) (fmap mkTVer <$> hlsGHCVersions)
+        fromSrc    <- ghcSrcInstalled tver
-        pure ListResult { lVer = _tvVersion tver , lCross = _tvTarget tver , lTag = _viTags, lTool = t, lStray = False, lReleaseDay = _viReleaseDay, .. }
+        hlsPowered <- fmap (elem v) hlsGHCVersions
+        pure ListResult { lVer = v, lCross = Nothing , lTag = tags, lTool = t, lStray = False, .. }
       Cabal -> do
         lNoBindist <- fmap (isLeft . veitherToEither) $ runE @'[NoDownload] $ getDownloadInfo Cabal v
         let lSet = cSet == Just v
         let lInstalled = elem v $ rights cabals
         pure ListResult { lVer    = v
                         , lCross  = Nothing
-                        , lTag    = _viTags
+                        , lTag    = tags
                         , lTool   = t
+                        , fromSrc = False
                         , lStray  = False
                         , hlsPowered = False
-                        , lReleaseDay = _viReleaseDay
                         , ..
                         }
       GHCup -> do
         let lSet       = prettyPVP ghcUpVer == prettyVer v
         let lInstalled = lSet
         pure ListResult { lVer    = v
-                        , lTag    = _viTags
+                        , lTag    = tags
                         , lCross  = Nothing
                         , lTool   = t
+                        , fromSrc = False
                         , lStray  = False
                         , lNoBindist = False
                         , hlsPowered = False
-                        , lReleaseDay = _viReleaseDay
                         , ..
                         }
       HLS -> do
@@ -368,11 +379,11 @@ listVersions lt' criteria hideOld showNightly days = do
         let lInstalled = elem v $ rights hlses
         pure ListResult { lVer    = v
                         , lCross  = Nothing
-                        , lTag    = _viTags
+                        , lTag    = tags
                         , lTool   = t
+                        , fromSrc = False
                         , lStray  = False
                         , hlsPowered = False
-                        , lReleaseDay = _viReleaseDay
                         , ..
                         }
       Stack -> do
@@ -381,42 +392,19 @@ listVersions lt' criteria hideOld showNightly days = do
         let lInstalled = elem v $ rights stacks
         pure ListResult { lVer    = v
                         , lCross  = Nothing
-                        , lTag    = _viTags
+                        , lTag    = tags
                         , lTool   = t
+                        , fromSrc = False
                         , lStray  = False
                         , hlsPowered = False
-                        , lReleaseDay = _viReleaseDay
                         , ..
                         }
 
 
   filter' :: [ListResult] -> [ListResult]
-  filter' = filterNightly . filterOld . filter (\lr -> foldr (\a b -> fromCriteria a lr && b) True criteria) . filterDays
+  filter' lr = case criteria of
-
+    Nothing            -> lr
-  filterDays :: [ListResult] -> [ListResult]
+    Just ListInstalled -> filter (\ListResult {..} -> lInstalled) lr
-  filterDays lrs = case days of
+    Just ListSet       -> filter (\ListResult {..} -> lSet) lr
-                     (Nothing, Nothing)    -> lrs
+    Just ListAvailable -> filter (\ListResult {..} -> not lNoBindist) lr
-                     (Just from, Just to') -> filter (\ListResult{..} -> maybe False (\d -> d >= from && d <= to') lReleaseDay) lrs
-                     (Nothing, Just to')   -> filter (\ListResult{..} -> maybe False (<= to')                      lReleaseDay) lrs
-                     (Just from, Nothing)  -> filter (\ListResult{..} -> maybe False (>= from)                     lReleaseDay) lrs
-
-  fromCriteria :: ListCriteria -> ListResult -> Bool
-  fromCriteria lc ListResult{..} = case lc of
-    ListInstalled  b -> f b lInstalled
-    ListSet        b -> f b lSet
-    ListAvailable  b -> f b $ not lNoBindist
-   where
-    f b
-      | b         = id
-      | otherwise = not
-
-  filterOld :: [ListResult] -> [ListResult]
-  filterOld lr
-    | hideOld   = filter (\ListResult {..} -> lInstalled || Old `notElem` lTag) lr
-    | otherwise = lr
-
-  filterNightly :: [ListResult] -> [ListResult]
-  filterNightly lr
-    | showNightly = lr
-    | otherwise   = filter (\ListResult {..} -> lInstalled || (Nightly `notElem` lTag && LatestNightly `notElem` lTag)) lr
 

lib/GHCup/Prelude.hs

@@ -77,14 +77,8 @@ runBothE' a1 a2 = do
       (_       , VLeft e ) -> throwSomeE e
       (VRight _, VRight _) -> pure ()
 
--- "throwSomeE" function has been upstreamed in haskus-utils-variant-3.3
--- So, only conditionally include this shim if
--- haskus-utils-variant version is < 3.3
 
-#if MIN_VERSION_haskus_utils_variant(3,3,0)
-#else
 -- | Throw some exception
 throwSomeE :: forall es' es a m. (Monad m, LiftVariant es' es) => V es' -> Excepts es m a
 {-# INLINABLE throwSomeE #-}
 throwSomeE = Excepts . pure . VLeft . liftVariant
-#endif

lib/GHCup/Prelude/Logger.hs

@@ -34,7 +34,6 @@ import           Control.Monad.IO.Class
 import           Control.Monad.Reader
 import           Prelude                 hiding ( appendFile )
 import           System.FilePath
-import           System.IO
 import           System.IO.Error
 import           Text.Regex.Posix
 
@@ -46,7 +45,7 @@ initGHCupFileLogging :: ( MonadReader env m
                         , HasDirs env
                         , MonadIO m
                         , MonadMask m
-                        ) => m Handle
+                        ) => m FilePath
 initGHCupFileLogging = do
   Dirs { logsDir } <- getDirs
   let logfile = fromGHCupPath logsDir </> "ghcup.log"
@@ -59,5 +58,4 @@ initGHCupFileLogging = do
   forM_ logFiles $ hideError doesNotExistErrorType . recycleFile . (fromGHCupPath logsDir </>)
 
   liftIO $ writeFile logfile ""
-  liftIO $ openFile logfile AppendMode
+  pure logfile
-

lib/GHCup/Stack.hs

@@ -38,7 +38,6 @@ import           Control.Monad.Trans.Resource
                                          hiding ( throwM )
 import           Data.Either
 import           Data.List
-import           Data.Ord
 import           Data.Maybe
 import           Data.Versions                hiding ( patch )
 import           Haskus.Utils.Variant.Excepts
@@ -280,6 +279,6 @@ rmStackVer ver = do
 
   when (Just ver == sSet) $ do
     sVers <- lift $ fmap rights getInstalledStacks
-    case headMay . sortBy (comparing Down) $ sVers of
+    case headMay . reverse . sort $ sVers of
       Just latestver -> setStack latestver
       Nothing        -> lift $ rmLink (binDir </> "stack" <> exeExt)

lib/GHCup/Types.hs

@@ -7,11 +7,7 @@
 {-# LANGUAGE FlexibleContexts  #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE TemplateHaskell   #-}
-{-# LANGUAGE TypeOperators   #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeFamilies        #-}
 {-# LANGUAGE DuplicateRecordFields #-}
-{-# LANGUAGE UndecidableInstances #-}
 
 {-|
 Module      : GHCup.Types
@@ -32,15 +28,12 @@ module GHCup.Types
 
 import {-# SOURCE #-} GHCup.Utils.Dirs          ( fromGHCupPath, GHCupPath )
 
-import           Control.Monad
-import           Control.Monad.Trans.Class      ( lift )
 import           Control.DeepSeq                ( NFData, rnf )
 import           Data.Map.Strict                ( Map )
 import           Data.List.NonEmpty             ( NonEmpty (..) )
-import           Data.Time.Calendar             ( Day )
 import           Data.Text                      ( Text )
 import           Data.Versions
-import           GHC.IO.Exception               ( ExitCode, IOException(..) )
+import           GHC.IO.Exception               ( ExitCode )
 import           Optics                         ( makeLenses )
 import           Text.PrettyPrint.HughesPJClass (Pretty, pPrint, text)
 import           URI.ByteString
@@ -52,12 +45,6 @@ import qualified Data.ByteString.Lazy          as BL
 import qualified Data.Text                     as T
 import qualified GHC.Generics                  as GHC
 
-import           Control.Monad.IO.Unlift
-import           UnliftIO.Exception
-import           Haskus.Utils.Variant.Excepts
-import           Haskus.Utils.Variant.VEither
-import Control.Monad.Except (ExceptT(..), runExceptT)
-
 
 #if !defined(BRICK)
 data Key = KEsc  | KChar Char | KBS | KEnter
@@ -116,7 +103,7 @@ instance NFData Requirements
 -- | Description of all binary and source downloads. This is a tree
 -- of nested maps.
 type GHCupDownloads = Map Tool ToolVersionSpec
-type ToolVersionSpec = Map GHCTargetVersion VersionInfo
+type ToolVersionSpec = Map Version VersionInfo
 type ArchitectureSpec = Map Architecture PlatformSpec
 type PlatformSpec = Map Platform PlatformVersionSpec
 type PlatformVersionSpec = Map (Maybe VersionRange) DownloadInfo
@@ -144,15 +131,11 @@ data GlobalTool = ShimGen
 
 instance NFData GlobalTool
 
-instance Pretty GlobalTool where
-  pPrint ShimGen = text "shimgen"
-
 
 -- | All necessary information of a tool version, including
 -- source download and per-architecture downloads.
 data VersionInfo = VersionInfo
   { _viTags        :: [Tag]              -- ^ version specific tag
-  , _viReleaseDay  :: Maybe Day
   , _viChangeLog   :: Maybe URI
   , _viSourceDL    :: Maybe DownloadInfo -- ^ source tarball
   , _viTestDL      :: Maybe DownloadInfo -- ^ test tarball
@@ -172,8 +155,6 @@ data Tag = Latest
          | Recommended
          | Prerelease
          | LatestPrerelease
-         | Nightly
-         | LatestNightly
          | Base PVP
          | Old                -- ^ old versions are hidden by default in TUI
          | UnknownTag String  -- ^ used for upwardscompat
@@ -185,22 +166,18 @@ tagToString :: Tag -> String
 tagToString Recommended        = "recommended"
 tagToString Latest             = "latest"
 tagToString Prerelease         = "prerelease"
-tagToString Nightly            = "nightly"
 tagToString (Base       pvp'') = "base-" ++ T.unpack (prettyPVP pvp'')
 tagToString (UnknownTag t    ) = t
 tagToString LatestPrerelease   = "latest-prerelease"
-tagToString LatestNightly      = "latest-nightly"
 tagToString Old                = ""
 
 instance Pretty Tag where
   pPrint Recommended        = text "recommended"
   pPrint Latest             = text "latest"
   pPrint Prerelease         = text "prerelease"
-  pPrint Nightly            = text "nightly"
   pPrint (Base       pvp'') = text ("base-" ++ T.unpack (prettyPVP pvp''))
   pPrint (UnknownTag t    ) = text t
   pPrint LatestPrerelease   = text "latest-prerelease"
-  pPrint LatestNightly   = text "latest-prerelease"
   pPrint Old                = mempty
 
 data Architecture = A_64
@@ -290,7 +267,6 @@ data DownloadInfo = DownloadInfo
   , _dlSubdir :: Maybe TarDir
   , _dlHash   :: Text
   , _dlCSize  :: Maybe Integer
-  , _dlOutput :: Maybe FilePath
   }
   deriving (Eq, Ord, GHC.Generic, Show)
 
@@ -608,9 +584,7 @@ data GHCTargetVersion = GHCTargetVersion
   { _tvTarget  :: Maybe Text
   , _tvVersion :: Version
   }
-  deriving (Ord, Eq, Show, GHC.Generic)
+  deriving (Ord, Eq, Show)
-
-instance NFData GHCTargetVersion
 
 data GitBranch = GitBranch
   { ref  :: String
@@ -720,37 +694,3 @@ type PromptQuestion = Text
 
 data PromptResponse = PromptYes | PromptNo
   deriving (Show, Eq)
-
-data ToolVersion = GHCVersion GHCTargetVersion
-                 | ToolVersion Version
-                 | ToolTag Tag
-                 | ToolDay Day
-
-instance Pretty ToolVersion where
-  pPrint (GHCVersion v) = pPrint v
-  pPrint (ToolVersion v) = pPrint v
-  pPrint (ToolTag t) = pPrint t
-  pPrint (ToolDay d) = text (show d)
-
-
-
-data BuildSystem = Hadrian
-                 | Make
-  deriving (Show, Eq)
-
-instance forall es m . (MonadUnliftIO m, Exception (V es)) => MonadUnliftIO (Excepts es m) where
-    withRunInIO exceptSToIO = Excepts $ fmap (either VLeft VRight) $ try $ do
-        withRunInIO $ \runInIO ->
-            exceptSToIO (runInIO . ((\case
-                                     VLeft v -> liftIO $ throwIO $ toException v
-                                     VRight a -> pure a) <=< runE))
-
-
-instance Exception (V '[]) where
-
-instance
-   ( Exception x
-   , Typeable xs
-   , Exception (V xs)
-   ) => Exception (V (x ': xs))
-

lib/GHCup/Types/JSON.hs

@@ -64,11 +64,9 @@ instance ToJSON Tag where
   toJSON Latest             = String "Latest"
   toJSON Recommended        = String "Recommended"
   toJSON Prerelease         = String "Prerelease"
-  toJSON Nightly            = String "Nightly"
   toJSON Old                = String "old"
   toJSON (Base       pvp'') = String ("base-" <> prettyPVP pvp'')
   toJSON LatestPrerelease   = String "LatestPrerelease"
-  toJSON LatestNightly      = String "LatestNightly"
   toJSON (UnknownTag x    ) = String (T.pack x)
 
 instance FromJSON Tag where
@@ -76,9 +74,7 @@ instance FromJSON Tag where
     "Latest"                             -> pure Latest
     "Recommended"                        -> pure Recommended
     "Prerelease"                         -> pure Prerelease
-    "Nightly"                            -> pure Nightly
     "LatestPrerelease"                   -> pure LatestPrerelease
-    "LatestNightly"                      -> pure LatestNightly
     "old"                                -> pure Old
     ('b' : 'a' : 's' : 'e' : '-' : ver') -> case pvp (T.pack ver') of
       Right x -> pure $ Base x
@@ -95,29 +91,13 @@ instance FromJSON URI where
       Right x -> pure x
       Left  e -> fail . show $ e
 
-instance ToJSON GHCTargetVersion where
-  toJSON = toJSON . tVerToText
-
-instance FromJSON GHCTargetVersion where
-  parseJSON = withText "GHCTargetVersion" $ \t -> case MP.parse ghcTargetVerP "" t of
-    Right x -> pure x
-    Left  e -> fail $ "Failure in GHCTargetVersion (FromJSON)" <> show e
-
-instance ToJSONKey GHCTargetVersion where
-  toJSONKey = toJSONKeyText $ \x -> tVerToText x
-
-instance FromJSONKey GHCTargetVersion where
-  fromJSONKey = FromJSONKeyTextParser $ \t -> case MP.parse ghcTargetVerP "" t of
-    Right x -> pure x
-    Left  e -> fail $ "Failure in GHCTargetVersion (FromJSONKey)" <> show e
-
 instance ToJSON Versioning where
   toJSON = toJSON . prettyV
 
 instance FromJSON Versioning where
   parseJSON = withText "Versioning" $ \t -> case versioning t of
     Right x -> pure x
-    Left  e -> fail $ "Failure in GHCTargetVersion (FromJSON)" <> show e
+    Left  e -> fail $ "Failure in Version (FromJSON)" <> show e
 
 instance ToJSONKey Versioning where
   toJSONKey = toJSONKeyText $ \x -> prettyV x

lib/GHCup/Utils.hs

@@ -62,6 +62,7 @@ import           Control.Monad.Trans.Resource
                                          hiding ( throwM )
 import           Control.Monad.IO.Unlift        ( MonadUnliftIO( withRunInIO ) )
 import           Data.Char                      ( isHexDigit )
+import           Data.Bifunctor                 ( first )
 import           Data.ByteString                ( ByteString )
 import           Data.Either
 import           Data.Foldable
@@ -93,7 +94,6 @@ import qualified Streamly.Prelude              as S
 import Control.DeepSeq (force)
 import GHC.IO (evaluate)
 import System.Environment (getEnvironment, setEnv)
-import Data.Time (Day(..), diffDays, addDays)
 
 
 -- $setup
@@ -288,6 +288,13 @@ ghcInstalled ver = do
   liftIO $ doesDirectoryExist (fromGHCupPath ghcdir)
 
 
+-- | Whether the given GHC version is installed from source.
+ghcSrcInstalled :: (MonadIO m, MonadReader env m, HasDirs env, MonadThrow m) => GHCTargetVersion -> m Bool
+ghcSrcInstalled ver = do
+  ghcdir <- ghcupGHCDir ver
+  liftIO $ doesFileExist (fromGHCupPath ghcdir </> ghcUpSrcBuiltFile)
+
+
 -- | Whether the given GHC version is set as the current.
 ghcSet :: (MonadReader env m, HasDirs env, MonadThrow m, MonadIO m)
        => Maybe Text   -- ^ the target of the GHC version, if any
@@ -766,16 +773,13 @@ getGHCForPVP' pvpIn ghcs' mt = do
 -- Just (PVP {_pComponents = 8 :| [8,4]})
 getLatestToolFor :: MonadThrow m
                  => Tool
-                 -> Maybe Text
                  -> PVP
                  -> GHCupDownloads
-                 -> m (Maybe (PVP, VersionInfo, Maybe Text))
+                 -> m (Maybe (PVP, VersionInfo))
-getLatestToolFor tool target pvpIn dls = do
+getLatestToolFor tool pvpIn dls = do
-  let ls :: [(GHCTargetVersion, VersionInfo)]
+  let ls = fromMaybe [] $ preview (ix tool % to Map.toDescList) dls
-      ls = fromMaybe [] $ preview (ix tool % to Map.toDescList) dls
+  let ps = catMaybes $ fmap (\(v, vi) -> (,vi) <$> versionToPVP v) ls
-  let ps :: [((PVP, Text), VersionInfo, Maybe Text)]
+  pure . fmap (first fst) . headMay . filter (\((v, _), _) -> matchPVPrefix pvpIn v) $ ps
-      ps = catMaybes $ fmap (\(v, vi) -> (,vi, _tvTarget v) <$> versionToPVP (_tvVersion v)) ls
-  pure . fmap (\((pv', _), vi, mt) -> (pv', vi, mt)) . headMay . filter (\((v, _), _, t) -> matchPVPrefix pvpIn v && t == target) $ ps
 
 
 
@@ -880,41 +884,23 @@ intoSubdir bdir tardir = case tardir of
 -- | Get the tool version that has this tag. If multiple have it,
 -- picks the greatest version.
 getTagged :: Tag
-          -> Fold (Map.Map GHCTargetVersion VersionInfo) (GHCTargetVersion, VersionInfo)
+          -> Fold (Map.Map Version VersionInfo) (Version, VersionInfo)
 getTagged tag =
   to (Map.toDescList . Map.filter (\VersionInfo {..} -> tag `elem` _viTags))
   % folding id
 
-getByReleaseDay :: GHCupDownloads -> Tool -> Day -> Either (Maybe Day) (GHCTargetVersion, VersionInfo)
+getLatest :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
-getByReleaseDay av tool day = let mvv = fromMaybe mempty $ headOf (ix tool) av
-                                  mdv = Map.foldrWithKey (\k vi@VersionInfo{..} m ->
-                                            maybe m (\d -> let diff = diffDays d day
-                                                           in Map.insert (abs diff) (diff, (k, vi)) m) _viReleaseDay)
-                                          Map.empty mvv
-                              in case headMay (Map.toAscList mdv) of
-                                   Nothing -> Left Nothing
-                                   Just (absDiff, (diff, (k, vi)))
-                                     | absDiff == 0 -> Right (k, vi)
-                                     | otherwise -> Left (Just (addDays diff day))
-
-getByReleaseDayFold :: Day -> Fold (Map.Map GHCTargetVersion VersionInfo) (GHCTargetVersion, VersionInfo)
-getByReleaseDayFold day = to (Map.toDescList . Map.filter (\VersionInfo {..} -> Just day == _viReleaseDay)) % folding id
-
-getLatest :: GHCupDownloads -> Tool -> Maybe (GHCTargetVersion, VersionInfo)
 getLatest av tool = headOf (ix tool % getTagged Latest) av
 
-getLatestPrerelease :: GHCupDownloads -> Tool -> Maybe (GHCTargetVersion, VersionInfo)
+getLatestPrerelease :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
 getLatestPrerelease av tool = headOf (ix tool % getTagged LatestPrerelease) av
 
-getLatestNightly :: GHCupDownloads -> Tool -> Maybe (GHCTargetVersion, VersionInfo)
+getRecommended :: GHCupDownloads -> Tool -> Maybe (Version, VersionInfo)
-getLatestNightly av tool = headOf (ix tool % getTagged LatestNightly) av
-
-getRecommended :: GHCupDownloads -> Tool -> Maybe (GHCTargetVersion, VersionInfo)
 getRecommended av tool = headOf (ix tool % getTagged Recommended) av
 
 
 -- | Gets the latest GHC with a given base version.
-getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe (GHCTargetVersion, VersionInfo)
+getLatestBaseVersion :: GHCupDownloads -> PVP -> Maybe (Version, VersionInfo)
 getLatestBaseVersion av pvpVer =
   headOf (ix GHC % getTagged (Base pvpVer)) av
 
@@ -968,6 +954,11 @@ ghcToolFiles ver = do
   isNotAnyInfix xs t = foldr (\a b -> not (a `isInfixOf` t) && b) True xs
 
 
+-- | This file, when residing in @~\/.ghcup\/ghc\/\<ver\>\/@ signals that
+-- this GHC was built from source. It contains the build config.
+ghcUpSrcBuiltFile :: FilePath
+ghcUpSrcBuiltFile = ".ghcup_src_built"
+
 
 -- | Calls gmake if it exists in PATH, otherwise make.
 make :: ( MonadThrow m
@@ -1090,15 +1081,11 @@ darwinNotarization _ _ = pure $ Right ()
 
 
 
-getChangeLog :: GHCupDownloads -> Tool -> ToolVersion -> Maybe URI
+getChangeLog :: GHCupDownloads -> Tool -> Either Version Tag -> Maybe URI
-getChangeLog dls tool (GHCVersion v') =
+getChangeLog dls tool (Left v') =
   preview (ix tool % ix v' % viChangeLog % _Just) dls
-getChangeLog dls tool (ToolVersion (mkTVer -> v')) =
+getChangeLog dls tool (Right tag) =
-  preview (ix tool % ix v' % viChangeLog % _Just) dls
-getChangeLog dls tool (ToolTag tag) =
   preview (ix tool % pre (getTagged tag) % to snd % viChangeLog % _Just) dls
-getChangeLog dls tool (ToolDay day) =
-  preview (ix tool % pre (getByReleaseDayFold day) % to snd % viChangeLog % _Just) dls
 
 
 -- | Execute a build action while potentially cleaning up:
@@ -1182,7 +1169,7 @@ rmBDir dir = withRunInIO (\run -> run $
            $ rmPathForcibly dir)
 
 
-getVersionInfo :: GHCTargetVersion
+getVersionInfo :: Version
                -> Tool
                -> GHCupDownloads
                -> Maybe VersionInfo
@@ -1212,7 +1199,7 @@ ensureGlobalTools
       (GHCupInfo _ _ gTools) <- lift getGHCupInfo
       dirs <- lift getDirs
       shimDownload <- liftE $ lE @_ @'[NoDownload]
-        $ maybe (Left (NoDownload' ShimGen)) Right $ Map.lookup ShimGen gTools
+        $ maybe (Left NoDownload) Right $ Map.lookup ShimGen gTools
       let dl = downloadCached' shimDownload (Just "gs.exe") Nothing
       void $ (\DigestError{} -> do
           lift $ logWarn "Digest doesn't match, redownloading gs.exe..."

lib/GHCup/Utils/Dirs.hs

@@ -279,7 +279,7 @@ ghcupCacheDir
             Nothing -> do
               home <- liftIO getHomeDirectory
               pure (home </> ".cache")
-          pure (GHCupPath (bdir </> "ghcup" </> "cache"))
+          pure (GHCupPath (bdir </> "ghcup"))
         else ghcupBaseDir <&> (\(GHCupPath gp) -> GHCupPath (gp </> "cache"))
 
 
@@ -308,7 +308,19 @@ ghcupLogsDir
 -- If 'GHCUP_USE_XDG_DIRS' is set (to anything),
 -- then uses 'XDG_CACHE_HOME/ghcup/db as per xdg spec.
 ghcupDbDir :: IO GHCupPath
-ghcupDbDir = ghcupBaseDir <&> (\(GHCupPath gp) -> GHCupPath (gp </> "db"))
+ghcupDbDir
+  | isWindows = ghcupBaseDir <&> (\(GHCupPath gp) -> GHCupPath (gp </> "db"))
+  | otherwise = do
+      xdg <- useXDG
+      if xdg
+        then do
+          bdir <- lookupEnv "XDG_CACHE_HOME" >>= \case
+            Just r  -> pure r
+            Nothing -> do
+              home <- liftIO getHomeDirectory
+              pure (home </> ".cache")
+          pure (GHCupPath (bdir </> "ghcup" </> "db"))
+        else ghcupBaseDir <&> (\(GHCupPath gp) -> GHCupPath (gp </> "db"))
 
 
 -- | '~/.ghcup/trash'.

lib/GHCup/Version.hs

@@ -52,7 +52,7 @@ versionCmp ver1 (VR_lteq ver2) = ver1 <= ver2
 versionCmp ver1 (VR_eq ver2)   = ver1 == ver2
 
 versionRange :: V.Versioning -> VersionRange -> Bool
-versionRange ver' (SimpleRange cmps) = all (versionCmp ver') cmps
+versionRange ver' (SimpleRange cmps) = and $ fmap (versionCmp ver') cmps
 versionRange ver' (OrRange cmps range) = 
   versionRange ver' (SimpleRange cmps) || versionRange ver' range
 

scripts/bootstrap/bootstrap-haskell

@@ -28,7 +28,7 @@
 
 plat="$(uname -s)"
 arch=$(uname -m)
-ghver="0.1.19.4"
+ghver="0.1.19.2"
 : "${GHCUP_BASE_URL:=https://downloads.haskell.org/~ghcup}"
 
 export GHCUP_SKIP_UPDATE_CHECK=yes
@@ -851,8 +851,8 @@ case $ask_stack_answer in
 		;;
 	2)
         (_eghcup --cache install stack) || die "Stack installation failed"
-        edo mkdir -p "${STACK_ROOT:-$HOME/.stack}"/hooks
+        edo mkdir -p "${STACK_ROOOT:-$HOME/.stack}"/hooks
-        hook_exe="${STACK_ROOT:-$HOME/.stack}"/hooks/ghc-install.sh
+        hook_exe="${STACK_ROOOT:-$HOME/.stack}"/hooks/ghc-install.sh
         hook_url="https://www.haskell.org/ghcup/sh/hooks/stack/ghc-install.sh"
 
         if [ -e "${hook_exe}" ] ; then

scripts/bootstrap/bootstrap-haskell.ps1

@@ -40,13 +40,10 @@ param (
     # Whether to disable use of curl.exe
     [switch]$DisableCurl,
     # The Msys2 version to download (e.g. 20221216)
-    [string]$Msys2Version,
+    [string]$Msys2Version
-    # The Msys2 sha256sum hash
-    [string]$Msys2Hash
 )
 
 $DefaultMsys2Version = "20221216"
-$DefaultMsys2Hash = "18370d32b0264915c97e3d7c618f7b32d48ad80858923883fde5145acd32ca0f"
 
 $Silent = !$Interactive
 
@@ -433,12 +430,9 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
 	if (!($Msys2Version)) {
 		$Msys2Version = $DefaultMsys2Version
 	}
-	if (!($Msys2Hash)) {
-		$Msys2Hash = $DefaultMsys2Hash
-	}
     Print-Msg -msg ('Downloading Msys2 archive {0}...' -f $Msys2Version)
     $archive = ('msys2-base-x86_64-{0}.sfx.exe' -f $Msys2Version)
-    $msysUrl = ('https://downloads.haskell.org/ghcup/msys2/{0}' -f "$archive")
+    $msysUrl = ('https://repo.msys2.org/distrib/x86_64/{0}' -f "$archive")
     $archivePath = ('{0}\{1}' -f ([IO.Path]::GetTempPath()), "$archive")
 
     if ((Get-Command -Name 'curl.exe' -ErrorAction SilentlyContinue) -and !($DisableCurl)) {
@@ -446,11 +440,6 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
     } else {
       Get-FileWCSynchronous -url "$msysUrl" -destinationFolder ([IO.Path]::GetTempPath()) -includeStats
     }
-	$Msys2HashChecked = Get-FileHash -Algorithm SHA256 "${archivePath}"
-	if (!($Msys2HashChecked.Hash -eq $Msys2Hash)) {
-		Print-Msg -color Red -msg ("Hashes don't match, got {0}, but expected {1}" -f $Msys2HashChecked, $Msys2Hash)
-		Exit 1
-	}
 
     Print-Msg -msg 'Extracting Msys2 archive...'
     $null = & "$archivePath" '-y' ('-o{0}' -f $GhcupDir)  # Extract
@@ -459,7 +448,7 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
     Print-Msg -msg 'Processing MSYS2 bash for first time use...'
     Exec "$Bash" '-lc' 'exit'
 
-    Exec "$env:windir\system32\taskkill.exe" /F /FI "MODULES eq msys-2.0.dll"
+    Exec "$env:windir\system32\taskkill.exe" /F /FI `"MODULES eq msys-2.0.dll`"
 
     Print-Msg -msg 'Upgrading full system...'
     Exec "$Bash" '-lc' 'pacman --noconfirm -Syuu'

scripts/releasing/create-yaml-snippet.sh

@@ -1,67 +0,0 @@
-#!/bin/bash
-
-set -eu
-set -o pipefail
-
-RELEASE=$1
-
-get_sha() {
-    sha256sum "$1" | awk '{ print $1 }'
-}
-
-cd "gh-release-artifacts/v${RELEASE}"
-
-cat <<EOF > /dev/stdout
-  GHCup:
-    ${RELEASE}:
-      viTags:
-      - Recommended
-      - Latest
-      viChangeLog: https://github.com/haskell/ghcup-hs/blob/master/CHANGELOG.md
-      viSourceDL:
-        dlUri: https://downloads.haskell.org/~ghcup/${RELEASE}/ghcup-${RELEASE}-src.tar.gz
-        dlSubdir: ghcup-${RELEASE}
-        dlHash: $(get_sha "ghcup-${RELEASE}-src.tar.gz")
-      viArch:
-        A_64:
-          Linux_UnknownLinux:
-            unknown_versioning: &ghcup-64
-              dlUri: https://downloads.haskell.org/~ghcup/${RELEASE}/x86_64-linux-ghcup-${RELEASE}
-              dlHash: $(get_sha "x86_64-linux-ghcup-${RELEASE}")
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/${RELEASE}/x86_64-apple-darwin-ghcup-${RELEASE}
-              dlHash: $(get_sha "x86_64-apple-darwin-ghcup-${RELEASE}")
-          FreeBSD:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/${RELEASE}/x86_64-portbld-freebsd-ghcup-${RELEASE}
-              dlHash: $(get_sha "x86_64-portbld-freebsd-ghcup-${RELEASE}")
-          Windows:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/${RELEASE}/x86_64-mingw64-ghcup-${RELEASE}.exe
-              dlHash: $(get_sha "x86_64-mingw64-ghcup-${RELEASE}.exe")
-          Linux_Alpine:
-            unknown_versioning: *ghcup-64
-        A_32:
-          Linux_UnknownLinux:
-            unknown_versioning: &ghcup-32
-              dlUri: https://downloads.haskell.org/~ghcup/${RELEASE}/i386-linux-ghcup-${RELEASE}
-              dlHash: $(get_sha "i386-linux-ghcup-${RELEASE}")
-          Linux_Alpine:
-            unknown_versioning: *ghcup-32
-        A_ARM64:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/${RELEASE}/aarch64-linux-ghcup-${RELEASE}
-              dlHash: $(get_sha "aarch64-linux-ghcup-${RELEASE}")
-          Darwin:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/${RELEASE}/aarch64-apple-darwin-ghcup-${RELEASE}
-              dlHash: $(get_sha "aarch64-apple-darwin-ghcup-${RELEASE}")
-        A_ARM:
-          Linux_UnknownLinux:
-            unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/${RELEASE}/armv7-linux-ghcup-${RELEASE}
-              dlHash: $(get_sha "armv7-linux-ghcup-${RELEASE}")
-EOF
-

scripts/releasing/pull_release_artifacts.sh

@@ -29,7 +29,7 @@ gh release download "$RELEASE"
 
 # cirrus
 curl -L -o "x86_64-portbld-freebsd-ghcup-${TAG}" \
-	"https://api.cirrus-ci.com/v1/artifact/github/haskell/ghcup-hs/build/binaries/out/x86_64-portbld-freebsd-ghcup-${TAG}?branch=${RELEASE}"
+	"https://api.cirrus-ci.com/v1/artifact/github/haskell/ghcup-hs/build/binaries/out/x86_64-portbld-freebsd-ghcup-${RELEASE}?branch=${RELEASE}"
 
 sha256sum ./*-ghcup-* > SHA256SUMS
 gpg --detach-sign -u "${SIGNER}" SHA256SUMS

stack.yaml

@@ -1,36 +1,52 @@
-resolver: lts-20.20
+resolver: lts-18.28
 
 packages:
   - .
 
 extra-deps:
-  - Cabal-3.6.3.0
+  - Cabal-3.6.2.0@sha256:e2266e14758c1f799220fad7f0d4b0b4ec567d81b7ba3faea17ff76d4c31de95,12437
-  - Cabal-syntax-3.10.1.0
+  - IfElse-0.85@sha256:6939b94acc6a55f545f63a168a349dd2fbe4b9a7cca73bf60282db5cc6aa47d2,445
-  - aeson-2.1.2.1
+  - ascii-string-1.0.1.4@sha256:fa34f1d9ba57e8e89c0d4c9cef5e01ba32cb2d4373d13f92dcc0b531a6c6749b,2582
-  - cabal-install-parsers-0.6.1
+  - base16-bytestring-0.1.1.7@sha256:0021256a9628971c08da95cb8f4d0d72192f3bb8a7b30b55c080562d17c43dd3,2231
+  - brick-0.64@sha256:f03fa14607c22cf48af99e24c44f79a0fb073f7ec229f15e969fed9ff73c93f6,16530
+  - brotli-0.0.0.0@sha256:2bf383a4cd308745740986be0b18381c5a0784393fe69b91456aacb2d603de46,2964
+  - brotli-streams-0.0.0.0@sha256:1af1e22f67b8bfd6ad0d05e61825e7a178d738f689ebbb21c1aab5f1bbcae176,2331
   - chs-cabal-0.1.1.1
-  - chs-deps-0.1.0.0
+  - chs-deps-0.1.0.0@sha256:0cdada6d2c682c41b20331b8c63c2ecfc7e806928585195fd544c9d41f3074fd,2496
-  - generic-arbitrary-0.2.2@sha256:202ffbf2032672a51318f2e80d7e75b72f8950e690346b4314f38bc7e39215f7,1189
+  - composition-prelude-3.0.0.2@sha256:1ffed216bd28d810fce0b5be83a661e2a892696d73b3f8de5c0f5edb9b5f0090,1216
-  - generically-0.1.1
   - haskus-utils-data-1.4@sha256:bfa94363b94b14779edd6834fbd59dbb847c3d7b8f48e3844f456ffdc077da4a,1466
   - haskus-utils-types-1.5.1@sha256:991c472f4e751e2f0d7aab6ad4220ef151d6160876dcf0511bbf876bbd432020,1298
-  - haskus-utils-variant-3.2.1
+  - haskus-utils-variant-3.2.1@sha256:791f4cf1e786eb578f4d37aef60986641f84c36e130164321f7d01542584066a,2200
-  - libarchive-3.0.3.2
+  - heaps-0.3.6.1@sha256:7928b759ca5180d35722c45948c0bde264229f3c99c1888188a3d9285f13d3d2,1340
+  - hpath-filepath-0.10.4@sha256:e9e44fb5fdbade7f30b5b5451257dbee15b6ef1aae4060034d73008bb3b5d878,1269
+  - hpath-posix-0.13.3@sha256:abe472cf16bccd3a8b8814865ed3551a728fde0f3a2baea2acc03023bec6c565,1615
+  - hspec-2.7.10@sha256:c9e82c90086acebac576552a06f3cabd249bba048edd1667c7fae0b1313d5bce,1712
+  - hspec-core-2.7.10@sha256:2aba6ea126442b29e8183ab27f1c811706b19b1d83b02f193a896f6fc1589d13,4621
+  - hspec-discover-2.7.10@sha256:d08bf5dd785629f589571477d9beb7cd91529471bd89f39517c1cb4b9b38160f,2184
+  - hspec-golden-aeson-0.9.0.0@sha256:aa17274114026661ba4dfc9c60c230673c8f408bd86482fd611d2d5cb6aff996,2179
+  - http-io-streams-0.1.6.0@sha256:53f5bab177efb52cd65ec396fd04ed59b93e5f919fb3700cd7dacd6cfce6f06d,3582
+  - libarchive-3.0.3.0
   - libyaml-streamly-0.2.1
-  - lzma-static-5.2.5.5
+  - lzma-static-5.2.5.3@sha256:2758ee58c35992fcf7db78e98684c357a16a82fa2a4e7c352a6c210c08c555d8,7308
-  - os-release-1.0.2.1
+  - optics-0.4@sha256:9fb69bf0195b8d8f1f8cd0098000946868b8a3c3ffb51e5b64f79fc600c3eb4c,6568
-  - parsec-3.1.15.0
+  - optics-core-0.4@sha256:59e04aebca536bd011ae50c781937f45af4c1456af1eb9fb578f9a69eee293cd,4995
+  - optics-extra-0.4@sha256:b9914f38aa7d5c92f231060d9168447f9f5a367c07df9bf47a003e3e786d5e05,3432
+  - optics-th-0.4@sha256:7c838b5b1d6998133bf8f0641c36197ed6cb468dc69515e1952f33f0bbe8e11d,2009
+  - os-release-1.0.1@sha256:1281c62081f438fc3f0874d3bae6a4887d5964ac25261ba06e29d368ab173467,2716
+  - primitive-0.7.1.0@sha256:29de6bfd0cf8ba023ceb806203dfbec0e51e3524e75ffe41056f70b4229c6f0f,2728
+  - regex-posix-clib-2.7
   - streamly-0.8.2@sha256:ec521b7c1c4db068501c35804af77f40b7d34232f5e29d9b99e722229040eb80,23500
-  - strict-base-0.4.0.0
+  - unicode-data-0.3.0@sha256:0545e079705a5381d0893f8fe8daaa08fc9174baeab269b9cf651817d8eadbc6,5123
-  - text-2.0.2
+  - strict-base-0.4.0.0@sha256:2ff4e43cb95eedf2995558d7fc34d19362846413dd39e6aa6a5b3ea8228fef9f,1248
-  - yaml-streamly-0.12.2
+  - xor-0.0.1.0@sha256:f8362b4a68562b9afbcd727ff64c1a303970df3a032e0033d2f4c094c3501df3,2243
+  - yaml-streamly-0.12.1
 
 flags:
   http-io-streams:
     brotli: false
 
   libarchive:
-    system-libarchive: true
+    system-libarchive: false
 
   regex-posix:
     _regex-posix-clib: true

test/GHCup/ArbitraryTypes.hs

@@ -11,7 +11,6 @@ import           GHCup.Types
 import           Data.ByteString                ( ByteString )
 import           Data.Versions
 import           Data.List.NonEmpty
-import           Data.Time.Calendar             ( Day(..) )
 import           Test.QuickCheck
 import           Test.QuickCheck.Arbitrary.ADT  ( ToADTArbitrary )
 import           Test.QuickCheck.Arbitrary.Generic
@@ -77,9 +76,6 @@ instance Arbitrary Port where
   arbitrary = genericArbitrary
   shrink    = genericShrink
 
-instance Arbitrary Day where
-  arbitrary = ModifiedJulianDay . fromIntegral <$> (chooseAny :: Gen Int)
-
 instance Arbitrary (URIRef Absolute) where
   arbitrary =
     URI <$> arbitrary <*> pure Nothing <*> arbitrary <*> pure (Query []) <*> pure Nothing
@@ -183,10 +179,6 @@ instance Arbitrary GHCupInfo where
   arbitrary = genericArbitrary
   shrink    = genericShrink
 
-instance Arbitrary GHCTargetVersion where
-  arbitrary = GHCTargetVersion Nothing <$> arbitrary
-  shrink    = genericShrink
-
 
 -- our maps are nested... the default size easily blows up most ppls ram