Integrate stack better

.gitlab/script/ghcup_version.sh

@@ -116,20 +116,7 @@ else
 	if [ "${OS}" = "LINUX" ] ; then
 		eghcup --downloader=wget prefetch ghc 8.10.3
 		eghcup --offline install ghc 8.10.3
-		if [ "${ARCH}" = "64" ] ; then
-			expected=$(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghc-8.10.3-linux.files" | sort)
-			actual=$(cd "${GHCUP_DIR}/ghc/8.10.3/" && find | sort)
-			[ "${actual}" = "${expected}" ]
-			unset actual expected
-		fi
-	elif [ "${OS}" = "WINDOWS" ] ; then
-		eghcup prefetch ghc 8.10.3
-		eghcup --offline install ghc 8.10.3
-		expected=$(cat "$( cd "$(dirname "$0")" ; pwd -P )/../ghc-8.10.3-windows.files" | sort)
-		actual=$(cd "${GHCUP_DIR}/ghc/8.10.3/" && find | sort)
-		[ "${actual}" = "${expected}" ]
-		unset actual expected
-	else
+	else # test wget a bit
 		eghcup prefetch ghc 8.10.3
 		eghcup --offline install ghc 8.10.3
 	fi
@@ -209,21 +196,6 @@ sha3=$(sha_sum "${GHCUP_DIR}/cache/ghcup-${JSON_VERSION}.yaml")
 [ "${etag2}" = "${etag3}" ]
 [ "${sha2}" = "${sha3}" ]
 
-# test isolated installs
-eghcup install ghc -i "$(pwd)/isolated" 8.10.5
-[ "$(isolated/bin/ghc --numeric-version)" = "8.10.5" ]
-! eghcup install ghc -i "$(pwd)/isolated" 8.10.5
-if [ "${ARCH}" = "64" ] ; then
-	if [ "${OS}" = "LINUX" ] || [ "${OS}" = "WINDOWS" ] ; then
-		eghcup install cabal -i "$(pwd)/isolated" 3.4.0.0
-		[ "$(isolated/cabal --numeric-version)" = "3.4.0.0" ]
-		eghcup install stack -i "$(pwd)/isolated" 2.7.3
-		[ "$(isolated/stack --numeric-version)" = "2.7.3" ]
-		eghcup install hls -i "$(pwd)/isolated" 1.3.0
-		[ "$(isolated/haskell-language-server-wrapper --numeric-version)" = "1.3.0" ] ||
-			[ "$(isolated/haskell-language-server-wrapper --numeric-version)" = "1.3.0.0" ]
-	fi
-fi
 
 eghcup upgrade
 eghcup upgrade -f

README.md

@@ -19,6 +19,8 @@ Similar in scope to [rustup](https://github.com/rust-lang-nursery/rustup.rs), [p
      * [Env variables](#env-variables)
      * [Installing custom bindists](#installing-custom-bindists)
      * [Tips and tricks](#tips-and-tricks)
+     * [Stack hooks](#stack-hooks)
+     * [Sharing MSys2 between stack and ghcup](#sharing-msys2-between-stack-and-ghcup)
    * [Design goals](#design-goals)
    * [How](#how)
    * [Known users](#known-users)
@@ -139,6 +141,10 @@ This is the complete list of env variables that change GHCup behavior:
 * `GHCUP_SKIP_UPDATE_CHECK`: Skip the (possibly annoying) update check when you run a command
 * `CC`/`LD` etc.: full environment is passed to the build system when compiling GHC via GHCup
 
+On windows, there are additional variables:
+
+* `GHCUP_MSYS2`: where to find msys2, so we can invoke shells and other cool stuff
+
 ### Installing custom bindists
 
 There are a couple of good use cases to install custom bindists:
@@ -202,6 +208,36 @@ with_ghc 8.10.5 code path/to/haskell/source
 Cabal and HLS will now see `8.10.5` as the primary GHC, without the need to
 run `ghcup set` all the time when switching between projects.
 
+### Stack hooks
+
+GHCup distributes a patched Stack, which has support for custom installation hooks, see:
+
+* https://github.com/commercialhaskell/stack/pull/5585
+
+Usually, the bootstrap script will already install a hook for you. If not,
+download it [here](https://gitlab.haskell.org/haskell/ghcup-hs/-/tree/master/hooks/stack/ghc-install.sh),
+place it in `~/.stack/hooks/ghc-install.sh` and make sure it's executable.
+
+Hooks aren't run when `system-ghc: true` is set in `stack.yaml`. If you want stack
+to never fall back to its own installation logic if ghcup fails, run the following command:
+
+```sh
+stack config set install-ghc false --global
+```
+
+### Sharing MSys2 between stack and ghcup
+
+You can tell stack to use GHCup's MSys2 installation. Add the following lines to `~/.stack/config.yaml`:
+
+```yml
+skip-msys: true
+extra-path:
+  - "C:\\ghcup\\msys64\\usr\\bin"
+  - "C:\\ghcup\\msys64\\mingw64\\bin"
+extra-include-dirs: "C:\\ghcup\\msys64\\mingw64\\include"
+extra-lib-dirs: "C:\\ghcup\\msys64\\mingw64\\lib"
+```
+
 ## Design goals
 
 1. simplicity
@@ -278,18 +314,6 @@ to figure out whether you have the correct toolchain and
 the correct dependencies. Refer to [the official docs](https://ghc.haskell.org/trac/ghc/wiki/Building/Preparation/Linux)
 on how to prepare your environment for building GHC.
 
-### Stack support
-
-There may be a number of bugs when trying to make ghcup installed GHC versions work with stack,
-such as:
-
-- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/188
-
-Further, stack's upgrade procedure may break/confuse ghcup. There are a number of integration
-issues discussed here:
-
-- https://gitlab.haskell.org/haskell/ghcup-hs/-/issues/153
-
 ### Windows support
 
 Windows support is in early stages. Since windows doesn't support symbolic links properly,

app/ghcup-gen/Validate.hs

@@ -237,7 +237,7 @@ validateTarballs (TarballFilter etool versionRegex) dls gt = do
                   ($(logError) $ T.pack $ prettyShow e)
                 liftIO $ exitWith (ExitFailure 2)
 
-    let appstate = AppState (Settings True False Never Curl True GHCupURL False) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq
+    let appstate = AppState (Settings True False Never Curl False GHCupURL False) dirs defaultKeyBindings (GHCupInfo mempty mempty mempty) pfreq
 
     r <-
       runLogger

app/ghcup/BrickMain.hs

@@ -440,29 +440,27 @@ install' _ (_, ListResult {..}) = do
               , TagNotFound
               , DigestError
               , DownloadFailed
-              , DirNotEmpty
               , NoUpdate
               , TarDirDoesNotExist
-              , FileAlreadyExistsError
               ]
 
   run (do
       case lTool of
         GHC   -> do
           let vi = getVersionInfo lVer GHC dls
-          liftE $ installGHCBin lVer Nothing $> vi
+          liftE $ installGHCBin lVer $> vi
         Cabal -> do
           let vi = getVersionInfo lVer Cabal dls
-          liftE $ installCabalBin lVer Nothing $> vi
+          liftE $ installCabalBin lVer $> vi
         GHCup -> do
           let vi = snd <$> getLatest dls GHCup
           liftE $ upgradeGHCup Nothing False $> vi
         HLS   -> do
           let vi = getVersionInfo lVer HLS dls
-          liftE $ installHLSBin lVer Nothing $> vi
+          liftE $ installHLSBin lVer $> vi
         Stack -> do
           let vi = getVersionInfo lVer Stack dls
-          liftE $ installStackBin lVer Nothing $> vi
+          liftE $ installStackBin lVer $> vi
     )
     >>= \case
           VRight vi                         -> do

app/ghcup/Main.hs

@@ -138,7 +138,6 @@ data InstallOptions = InstallOptions
   , instPlatform :: Maybe PlatformRequest
   , instBindist  :: Maybe URI
   , instSet      :: Bool
-  , isolateDir   :: Maybe FilePath
   }
 
 data SetCommand = SetGHC SetOptions
@@ -186,7 +185,6 @@ data GHCCompileOptions = GHCCompileOptions
   , ovewrwiteVer :: Maybe Version
   , buildFlavour :: Maybe String
   , hadrian      :: Bool
-  , isolateDir   :: Maybe FilePath
   }
 
 data UpgradeOpts = UpgradeInplace
@@ -576,7 +574,7 @@ Examples:
 
 installOpts :: Maybe Tool -> Parser InstallOptions
 installOpts tool =
-  (\p (u, v) b is -> InstallOptions v p u b is)
+  (\p (u, v) b -> InstallOptions v p u b)
     <$> optional
           (option
             (eitherReader platformParser)
@@ -605,15 +603,6 @@ installOpts tool =
           (long "set" <> help
             "Set as active version after install"
           )
-    <*> optional
-          (option
-           (eitherReader isolateParser)
-           (  short 'i'
-           <> long "isolate"
-           <> metavar "DIR"
-           <> help "install in an isolated dir instead of the default one"
-           )
-          )
 
 
 setParser :: Parser (Either SetCommand SetOptions)
@@ -1011,15 +1000,6 @@ ghcCompileOpts =
     <*> switch
           (long "hadrian" <> help "Use the hadrian build system instead of make (only git versions seem to be properly supported atm)"
           )
-    <*> optional
-          (option
-            (eitherReader isolateParser)
-            (  short 'i'
-            <> long "isolate"
-            <> metavar "DIR"
-            <> help "install in an isolated directory instead of the default one, no symlinks to this installation will be made"
-            )
-           )
 
 
 toolVersionParser :: Parser ToolVersion
@@ -1235,10 +1215,6 @@ platformParser s' = case MP.parse (platformP <* MP.eof) "" (T.pack s') of
 bindistParser :: String -> Either String URI
 bindistParser = first show . parseURI strictURIParserOptions . UTF8.fromString
 
-isolateParser :: FilePath -> Either String FilePath
-isolateParser f = case isValid f of
-              True -> Right $ normalise f
-              False -> Left "Please enter a valid filepath for isolate dir."
 
 toSettings :: Options -> IO (Settings, KeyBindings)
 toSettings options = do
@@ -1469,8 +1445,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 #endif
                       , FileDoesNotExistError
                       , CopyError
-                      , NotInstalled
-                      , DirNotEmpty
                       , NoDownload
                       , NotInstalled
                       , BuildFailed
@@ -1480,7 +1454,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       , TarDirDoesNotExist
                       , NextVerNotFound
                       , NoToolVersionSet
-                      , FileAlreadyExistsError
                       ]
 
           let runInstTool mInstPlatform action' = do
@@ -1582,7 +1555,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                       , UnknownArchive
                       , TarDirDoesNotExist
                       , NotInstalled
-                      , DirNotEmpty
 #if !defined(TAR)
                       , ArchiveResult
 #endif
@@ -1645,23 +1617,22 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
           -----------------------
 
           let installGHC InstallOptions{..} =
-                (case instBindist of
-                   Nothing -> runInstTool instPlatform $ do
-                     (v, vi) <- liftE $ fromVersion instVer GHC
-                     liftE $ installGHCBin (_tvVersion v) isolateDir
-                     when instSet $ void $ liftE $ setGHC v SetGHCOnly
-                     pure vi
-                   Just uri -> do
-                     s' <- liftIO appState
-                     runInstTool' s'{ settings = settings {noVerify = True}} instPlatform $ do
+                  (case instBindist of
+                     Nothing -> runInstTool instPlatform $ do
                        (v, vi) <- liftE $ fromVersion instVer GHC
-                       liftE $ installGHCBindist
-                         (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
-                         (_tvVersion v)
-                         isolateDir
+                       liftE $ installGHCBin (_tvVersion v)
                        when instSet $ void $ liftE $ setGHC v SetGHCOnly
                        pure vi
-                  )
+                     Just uri -> do
+                       s' <- liftIO appState
+                       runInstTool' s'{ settings = settings {noVerify = True}} instPlatform $ do
+                         (v, vi) <- liftE $ fromVersion instVer GHC
+                         liftE $ installGHCBindist
+                           (DownloadInfo uri (Just $ RegexDir "ghc-.*") "")
+                           (_tvVersion v)
+                         when instSet $ void $ liftE $ setGHC v SetGHCOnly
+                         pure vi
+                    )
                     >>= \case
                           VRight vi -> do
                             runLogger $ $(logInfo) "GHC installation successful"
@@ -1690,7 +1661,7 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                 (case instBindist of
                    Nothing -> runInstTool instPlatform $ do
                      (v, vi) <- liftE $ fromVersion instVer Cabal
-                     liftE $ installCabalBin (_tvVersion v) isolateDir
+                     liftE $ installCabalBin (_tvVersion v)
                      pure vi
                    Just uri -> do
                      s' <- appState
@@ -1699,7 +1670,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                        liftE $ installCabalBindist
                            (DownloadInfo uri Nothing "")
                            (_tvVersion v)
-                           isolateDir
                        pure vi
                   )
                   >>= \case
@@ -1719,10 +1689,10 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                           pure $ ExitFailure 4
 
           let installHLS InstallOptions{..} =
-                 (case instBindist of
+                (case instBindist of
                    Nothing -> runInstTool instPlatform $ do
                      (v, vi) <- liftE $ fromVersion instVer HLS
-                     liftE $ installHLSBin (_tvVersion v) isolateDir
+                     liftE $ installHLSBin (_tvVersion v)
                      pure vi
                    Just uri -> do
                      s' <- appState
@@ -1731,7 +1701,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                        liftE $ installHLSBindist
                            (DownloadInfo uri Nothing "")
                            (_tvVersion v)
-                           isolateDir
                        pure vi
                   )
                   >>= \case
@@ -1751,20 +1720,19 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                           pure $ ExitFailure 4
 
           let installStack InstallOptions{..} =
-                 (case instBindist of
-                    Nothing -> runInstTool instPlatform $ do
-                      (v, vi) <- liftE $ fromVersion instVer Stack
-                      liftE $ installStackBin (_tvVersion v) isolateDir
-                      pure vi
-                    Just uri -> do
-                      s' <- appState
-                      runInstTool' s'{ settings = settings { noVerify = True}} instPlatform $ do
-                        (v, vi) <- liftE $ fromVersion instVer Stack
-                        liftE $ installStackBindist
-                            (DownloadInfo uri Nothing "")
-                            (_tvVersion v)
-                            isolateDir
-                        pure vi
+                (case instBindist of
+                   Nothing -> runInstTool instPlatform $ do
+                     (v, vi) <- liftE $ fromVersion instVer Stack
+                     liftE $ installStackBin (_tvVersion v)
+                     pure vi
+                   Just uri -> do
+                     s' <- appState
+                     runInstTool' s'{ settings = settings { noVerify = True}} instPlatform $ do
+                       (v, vi) <- liftE $ fromVersion instVer Stack
+                       liftE $ installStackBindist
+                           (DownloadInfo uri Nothing "")
+                           (_tvVersion v)
+                       pure vi
                   )
                   >>= \case
                         VRight vi -> do
@@ -1993,7 +1961,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                             addConfArgs
                             buildFlavour
                             hadrian
-                            isolateDir
                 GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
                 let vi = getVersionInfo (_tvVersion targetVer) GHC dls
                 when setCompile $ void $ liftE $

bootstrap-haskell

@@ -8,6 +8,7 @@
 #   * BOOTSTRAP_HASKELL_GHC_VERSION - the ghc version to install
 #   * BOOTSTRAP_HASKELL_CABAL_VERSION - the cabal version to install
 #   * BOOTSTRAP_HASKELL_INSTALL_STACK - whether to install latest stack
+#   * BOOTSTRAP_HASKELL_INSTALL_STACK_HOOK - whether to install stack hook as well
 #   * BOOTSTRAP_HASKELL_INSTALL_HLS - whether to install latest hls
 #   * BOOTSTRAP_HASKELL_ADJUST_BASHRC - whether to adjust PATH in bashrc (prepend)
 #   * BOOTSTRAP_HASKELL_ADJUST_CABAL_CONFIG - whether to adjust mingw paths in cabal.config on windows
@@ -508,17 +509,25 @@ ask_hls() {
 
 ask_stack() {
 	if [ -n "${BOOTSTRAP_HASKELL_INSTALL_STACK}" ] ; then
-		return 1
+		if [ -n "${BOOTSTRAP_HASKELL_INSTALL_STACK_HOOK}" ] ; then
+			return 2
+		else
+			return 1
+		fi
 	fi
 
 	if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 		echo "-------------------------------------------------------------------------------"
 
-		warn "Do you want to install stack?"
+		warn "Do you want to install stack and stack hooks?"
+		warn ""
 		warn "Stack is a haskell build tool similar to cabal that is used by some projects."
 		warn "Also see https://docs.haskellstack.org/"
 		warn ""
-		warn "[Y] Yes  [N] No  [?] Help (default is \"N\")."
+		warn "Stack hooks allow stack to use ghcup for GHC installation (usually stack handles"
+		warn "installation itself, leading to possibly duplicated GHC versions)."
+		warn ""
+		warn "[Y] Yes, with hooks  [L] Yes, no hooks  [N] No  [?] Help (default is \"N\")."
 		warn ""
 
 		while true; do
@@ -526,13 +535,16 @@ ask_stack() {
 
 			case $stack_answer in
 				[Yy]*)
+					return 2 ;;
+				[Ll]*)
 					return 1 ;;
 				[Nn]* | "")
 					return 0 ;;
 				*)
 					echo "Possible choices are:"
 					echo
-					echo "Y - Yes, install stack"
+					echo "Y - Yes, install stack with hooks"
+					echo "L - Yes, install stack without hooks"
 					echo "N - No, don't install anything more (default)"
 					echo
 					echo "Please make your choice and press ENTER."
@@ -636,7 +648,27 @@ esac
 
 case $ask_stack_answer in
 	1)
-		_eghcup --cache install stack || warn "Stack installation failed, continuing anyway"
+		{
+			_eghcup --cache install stack
+			edo stack update
+		} || warn "Stack installation failed, continuing anyway"
+		;;
+	2)
+		{
+			_eghcup --cache install stack
+		    edo stack update
+			if [ -n "${STACK_ROOT}" ] ; then
+				stack_root=$STACK_ROOT
+			else
+				stack_root=${HOME}/.stack
+			fi
+			edo mkdir -p "${stack_root}/hooks/"
+			edo curl -Lf "https://www.haskell.org/ghcup/sh/hooks/stack/ghc-install.sh" > "${stack_root}/hooks/ghc-install.sh"
+			edo chmod +x "${stack_root}/hooks/ghc-install.sh"
+			edo stack config set system-ghc  false --global
+			edo stack config set install-ghc false --global
+
+		} || warn "Stack installation failed, continuing anyway"
 		;;
 	*) ;;
 esac

bootstrap-haskell.ps1

@@ -29,6 +29,8 @@ param (
     [switch]$InBash,
     # Whether to install stack as well
     [switch]$InstallStack,
+    # Whether to install stack hooks as well
+    [switch]$InstallStackHook,
     # Whether to install hls as well
     [switch]$InstallHLS,
     # Skip adjusting cabal.config with mingw paths
@@ -223,6 +225,7 @@ $null = [Environment]::SetEnvironmentVariable("GHCUP_INSTALL_BASE_PREFIX", $Ghcu
 
 
 $GhcupDir = ('{0}\ghcup' -f $GhcupBasePrefix)
+$StackDir = ('{0}\sr' -f $GhcupBasePrefix)
 $MsysDir = ('{0}\msys64' -f $GhcupDir)
 $Bash = ('{0}\usr\bin\bash' -f $MsysDir)
 if (!($BootstrapUrl)) {
@@ -310,15 +313,28 @@ if (!($InstallHLS)) {
 }
 
 # ask whether to install stack
+$InstallStackDoc = @'
+Do you want to install stack and stack hooks?
+
+Stack is a haskell build tool similar to cabal that is used by some projects.
+Also see https://docs.haskellstack.org/
+
+Stack hooks allow stack to use ghcup for GHC installation (usually stack handles
+installation itself, leading to possibly duplicated GHC versions).
+'@
 if (!($InstallStack)) {
   if (!($Silent)) {
     $StackDecision = $Host.UI.PromptForChoice('Install stack'
-      , 'Do you want to install stack as well?'
-      , [System.Management.Automation.Host.ChoiceDescription[]] @('&Yes'
+      , $InstallStackDoc
+      , [System.Management.Automation.Host.ChoiceDescription[]] @('&Yes, with hooks'
+          '&Light install, without hooks'
           '&No'
-          '&Abort'), 1)
+          '&Abort'), 2)
 
     if ($StackDecision -eq 0) {
+      $InstallStack = $true
+	  $InstallStackHook = $true
+    } elseif ($StackDecision -eq 1) {
       $InstallStack = $true
     } elseif ($StackDecision -eq 2) {
       Exit 0
@@ -371,7 +387,7 @@ if (!(Test-Path -Path ('{0}' -f $MsysDir))) {
     Exec "$Bash" '-lc' 'pacman --noconfirm -Syuu'
 
     Print-Msg -msg 'Installing Dependencies...'
-    Exec "$Bash" '-lc' 'pacman --noconfirm -S --needed curl autoconf mingw-w64-x86_64-pkgconf'
+    Exec "$Bash" '-lc' 'pacman --noconfirm -S --needed curl mingw-w64-x86_64-pkgconf'
 
     Print-Msg -msg 'Updating SSL root certificate authorities...'
     Exec "$Bash" '-lc' 'pacman --noconfirm -S ca-certificates'
@@ -499,6 +515,11 @@ $SilentExport = 'export BOOTSTRAP_HASKELL_NONINTERACTIVE=1 ;'
 
 if ($InstallStack) {
   $StackInstallExport = 'export BOOTSTRAP_HASKELL_INSTALL_STACK=1 ;'
+  $null = [Environment]::SetEnvironmentVariable("STACK_ROOT", $StackDir, [System.EnvironmentVariableTarget]::User)
+}
+
+if ($InstallStackHook) {
+  $StackInstallHookExport = 'export BOOTSTRAP_HASKELL_INSTALL_STACK_HOOK=1 ;'
 }
 
 if ($InstallHLS) {
@@ -510,9 +531,9 @@ if (!($NoAdjustCabalConfig)) {
 }
 
 if ((Get-Process -ID $PID).ProcessName.StartsWith("bootstrap-haskell") -Or $InBash) {
-  Exec "$Bash" '-lc' ('{4} {6} {7} {8} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport)
+  Exec "$Bash" '-lc' ('{4} {6} {7} {8} {9} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; export STACK_ROOT=$(cygpath -m ''{10}/'') ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport, $StackInstallHookExport, $StackDir)
 } else {
-  Exec "$Msys2Shell" '-mingw64' '-mintty' '-c' ('{4} {6} {7} {8} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; trap ''echo Press any key to exit && read -n 1 && exit'' 2 ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash ; echo ''Press any key to exit'' && read -n 1' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport)
+  Exec "$Msys2Shell" '-mingw64' '-mintty' '-c' ('{4} {6} {7} {8} {9} [ -n ''{1}'' ] && export GHCUP_MSYS2=$(cygpath -m ''{1}'') ; [ -n ''{2}'' ] && export GHCUP_INSTALL_BASE_PREFIX=$(cygpath -m ''{2}/'') ; export PATH=$(cygpath -u ''{3}/bin''):$PATH ; export CABAL_DIR=''{5}'' ; export STACK_ROOT=$(cygpath -m ''{10}/'') ; trap ''echo Press any key to exit && read -n 1 && exit'' 2 ; [[ ''{0}'' = https* ]]  && curl --proto ''=https'' --tlsv1.2 -sSf {0} | bash || cat $(cygpath -m ''{0}'') | bash ; echo ''Press any key to exit'' && read -n 1' -f $BootstrapUrl, $MsysDir, $GhcupBasePrefix, $GhcupDir, $SilentExport, $CabalDirFull, $StackInstallExport, $HLSInstallExport, $AdjustCabalConfigExport, $StackInstallHookExport, $StackDir)
 }
 
 

ghcup-0.0.6.yaml

@@ -2206,8 +2206,7 @@ ghcupDownloads:
             unknown_versioning: *stack-271-64
     2.7.3:
       viTags:
-        - Latest
-        - Recommended
+        - old
       viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v273
       viPostInstall: *stack-post
       viArch:
@@ -2232,4 +2231,65 @@ ghcupDownloads:
                 RegexDir: "stack-.*"
           Linux_Alpine:
             unknown_versioning: *stack-273-64
+    2.7.3.1:
+      viTags:
+        - Latest
+        - Recommended
+      viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v273
+      viPostInstall: &stack-post-new |
+        Stack manages GHC versions internally by default. It can also use hooks to automatically
+        install and locate GHC versions utilizing GHCup:
+          https://gitlab.haskell.org/haskell/ghcup-hs#stack-hooks
 
+        Alternatively, you can also tell stack to use the system GHC version (whatever is in PATH):
+          stack config set system-ghc  true  --global
+
+        If you want stack to use GHCup's provided MSys2, follow the instructions here (not recommended):
+          https://gitlab.haskell.org/haskell/ghcup-hs/-/tree/stack-fork#sharing-msys2-between-stack-and-ghcup
+
+        Also check out: https://docs.haskellstack.org/en/stable/yaml_configuration
+
+        !!! GHCup ships a patched version of stack. Before reporting bugs to stack developers !!!
+        !!! make sure it is reproducible with the original stack version:                     !!!
+        !!!   https://docs.haskellstack.org/en/stable/install_and_upgrade/                    !!!
+      viArch:
+        A_64:
+          Linux_UnknownLinux:
+            unknown_versioning: &stack-2731-64
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/stack/2.7.3.1/stack-2.7.3.1-linux-x86_64.tar.gz
+              dlSubdir:
+                RegexDir: "stack-.*"
+              dlHash: 7c10090d568651208b6d6c003c8d78ef79099f4b472aea5ca800f3e4a7a1c6ce
+          Darwin:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/stack/2.7.3.1/stack-2.7.3.1-osx-x86_64.tar.gz
+              dlSubdir:
+                RegexDir: "stack-.*"
+              dlHash: 23030868be377d62ed324332d239ddd915b12f7a64c887f297e1b60a3f65894f
+          Windows:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/stack/2.7.3.1/stack-2.7.3.1-windows-x86_64.tar.bz2
+              dlHash: 983ac24219370cdf220f47f9edb17d0aeb831a1253fd777d322fd1bff358c511
+          Linux_Alpine:
+            unknown_versioning: *stack-2731-64
+          FreeBSD:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/stack/2.7.3.1/stack-2.7.3.1-freebsd-x86_64.tar.gz
+              dlHash: b6b1eb59981b8c1d3a04b061f03296b1540ecbadbc34cbd4fe712a575a155ee9
+        A_32:
+          Linux_UnknownLinux:
+            unknown_versioning: &stack-2731-32
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/stack/2.7.3.1/stack-2.7.3.1-linux-i386.tar.gz
+              dlHash: da2081d84517d16a8216e929582dd39caa19643c819b77c6f68f138bd177a758
+          Linux_Alpine:
+            unknown_versioning: *stack-2731-32
+        A_ARM64:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/stack/2.7.3.1/stack-2.7.3.1-linux-aarch64.tar.gz
+              dlHash: 0e1789852a476dd87f495fa0b481309398b2bafc00cf7c8d980c91977b39d9a6
+        A_ARM:
+          Linux_UnknownLinux:
+            unknown_versioning:
+              dlUri: https://downloads.haskell.org/ghcup/unofficial-bindists/stack/2.7.3.1/stack-2.7.3.1-linux-armv7.tar.gz
+              dlHash: 13d61616c169615d80381ea0c84e13540410b736a553565cd48d10b4d2bd7f23

hooks/stack/ghc-install.sh

@@ -0,0 +1,23 @@
+#!/bin/sh
+
+set -eu
+
+case $HOOK_GHC_TYPE in
+	bindist)
+		ghcup --offline whereis ghc $HOOK_GHC_VERSION || {
+			ghcup --cache install ghc $HOOK_GHC_VERSION && ghcup whereis ghc $HOOK_GHC_VERSION
+		}
+		;;
+	git)
+		>&2 echo "Hook doesn't support installing from source."
+		>&2 echo "Consider enabling stack GHC installs for this project, via:"
+		>&2 echo "    stack config set install-ghc true"
+		exit 1
+		;;
+	*)
+		>&2 echo "Unsupported GHC installation type: ${HOOK_GHC_TYPE}."
+		>&2 echo "Consider enabling stack GHC installs for this project, via:"
+		>&2 echo "    stack config set install-ghc true"
+		exit 2
+		;;
+esac

lib/GHCup.hs

@@ -186,7 +186,6 @@ installGHCBindist :: ( MonadFail m
                      )
                   => DownloadInfo    -- ^ where/how to download
                   -> Version         -- ^ the version to install
-                  -> Maybe FilePath  -- ^ isolated filepath if user passed any
                   -> Excepts
                        '[ AlreadyInstalled
                         , BuildFailed
@@ -196,22 +195,16 @@ installGHCBindist :: ( MonadFail m
                         , NotInstalled
                         , UnknownArchive
                         , TarDirDoesNotExist
-                        , DirNotEmpty
 #if !defined(TAR)
                         , ArchiveResult
 #endif
                         ]
                        m
                        ()
-installGHCBindist dlinfo ver isoFilepath = do
+installGHCBindist dlinfo ver = do
   let tver = mkTVer ver
-
   lift $ $(logDebug) [i|Requested to install GHC with #{ver}|]
-
-  case isoFilepath of
-    -- we only care for already installed errors in regular (non-isolated) installs
-    Nothing -> whenM (lift $ ghcInstalled tver) (throwE $ AlreadyInstalled GHC ver)
-    _ -> pure ()
+  whenM (lift $ ghcInstalled tver) (throwE $ AlreadyInstalled GHC ver)
 
   -- download (or use cached version)
   dl <- liftE $ downloadCached dlinfo Nothing
@@ -221,15 +214,9 @@ installGHCBindist dlinfo ver isoFilepath = do
 
   toolchainSanityChecks
   
-  case isoFilepath of
-    Just isoDir -> do                        -- isolated install
-      lift $ $(logInfo) [i|isolated installing GHC to #{isoDir}|]
-      liftE $ installPackedGHC dl (view dlSubdir dlinfo) isoDir ver
-    Nothing -> do                            -- regular install
-      liftE $ installPackedGHC dl (view dlSubdir dlinfo) ghcdir ver
+  liftE $ installPackedGHC dl (view dlSubdir dlinfo) ghcdir ver
 
-      -- make symlinks & stuff when regular install,
-      liftE $ postGHCInstall tver
+  liftE $ postGHCInstall tver
 
  where
   toolchainSanityChecks = do
@@ -263,7 +250,6 @@ installPackedGHC :: ( MonadMask m
                       '[ BuildFailed
                        , UnknownArchive
                        , TarDirDoesNotExist
-                       , DirNotEmpty
 #if !defined(TAR)
                        , ArchiveResult
 #endif
@@ -271,8 +257,6 @@ installPackedGHC :: ( MonadMask m
 installPackedGHC dl msubdir inst ver = do
   PlatformRequest {..} <- lift getPlatformReq
 
-  liftE $ installDestSanityCheck inst
-
   -- unpack
   tmpUnpack <- lift mkGhcupTmpDir
   liftE $ unpackToDir tmpUnpack dl
@@ -286,22 +270,6 @@ installPackedGHC dl msubdir inst ver = do
   liftE $ runBuildAction tmpUnpack
                          (Just inst)
                          (installUnpackedGHC workdir inst ver)
- where
-  -- | Does basic checks for isolated installs
-  -- Isolated Directory:
-  --   1. if it doesn't exist -> proceed
-  --   2. if it exists and is empty -> proceed
-  --   3. if it exists and is non-empty -> panic and leave the house
-  installDestSanityCheck :: ( MonadIO m
-                            , MonadCatch m
-                            ) =>
-                            FilePath ->
-                            Excepts '[DirNotEmpty] m ()
-  installDestSanityCheck isoDir = do
-    hideErrorDef [doesNotExistErrorType] () $ do
-      contents <- liftIO $ getDirectoryContentsRecursive isoDir
-      unless (null contents) (throwE $ DirNotEmpty isoDir)
-
 
 
 -- | Install an unpacked GHC distribution. This only deals with the GHC
@@ -332,6 +300,10 @@ installUnpackedGHC path inst ver = do
     setModificationTime dest mtime
 #else
   PlatformRequest {..} <- lift getPlatformReq
+  liftIO $ copyDirectoryRecursive path inst $ \source dest -> do
+    mtime <- getModificationTime source
+    copyFile source dest
+    setModificationTime dest mtime
 
   let alpineArgs
        | ver >= [vver|8.2.2|], Linux Alpine <- _rPlatform
@@ -371,7 +343,6 @@ installGHCBin :: ( MonadFail m
                  , MonadUnliftIO m
                  )
               => Version         -- ^ the version to install
-              -> Maybe FilePath  -- ^ isolated install filepath, if user passed any
               -> Excepts
                    '[ AlreadyInstalled
                     , BuildFailed
@@ -381,16 +352,15 @@ installGHCBin :: ( MonadFail m
                     , NotInstalled
                     , UnknownArchive
                     , TarDirDoesNotExist
-                    , DirNotEmpty
 #if !defined(TAR)
                     , ArchiveResult
 #endif
                     ]
                    m
                    ()
-installGHCBin ver isoFilepath = do
+installGHCBin ver = do
   dlinfo <- liftE $ getDownloadInfo GHC ver
-  installGHCBindist dlinfo ver isoFilepath
+  installGHCBindist dlinfo ver
 
 
 -- | Like 'installCabalBin', except takes the 'DownloadInfo' as
@@ -409,7 +379,6 @@ installCabalBindist :: ( MonadMask m
                        )
                     => DownloadInfo
                     -> Version
-                    -> Maybe FilePath -- ^ isolated install filepath, if user provides any.
                     -> Excepts
                          '[ AlreadyInstalled
                           , CopyError
@@ -422,28 +391,23 @@ installCabalBindist :: ( MonadMask m
 #if !defined(TAR)
                           , ArchiveResult
 #endif
-                          , FileAlreadyExistsError
                           ]
                          m
                          ()
-installCabalBindist dlinfo ver isoFilepath = do
+installCabalBindist dlinfo ver = do
   lift $ $(logDebug) [i|Requested to install cabal version #{ver}|]
 
   PlatformRequest {..} <- lift getPlatformReq
   Dirs {..} <- lift getDirs
 
-  case isoFilepath of
-    Nothing -> -- for regular install check if any previous versions installed
-      whenM
-        (lift (cabalInstalled ver) >>= \a -> liftIO $
-          handleIO (\_ -> pure False)
-            $ fmap (\x -> a && x)
-            -- ignore when the installation is a legacy cabal (binary, not symlink)
-            $ pathIsLink (binDir </> "cabal" <> exeExt)
-        )
-        (throwE $ AlreadyInstalled Cabal ver)
-
-    _ -> pure () -- check isn't required in isolated installs
+  whenM
+      (lift (cabalInstalled ver) >>= \a -> liftIO $
+        handleIO (\_ -> pure False)
+          $ fmap (\x -> a && x)
+          -- ignore when the installation is a legacy cabal (binary, not symlink)
+          $ pathIsLink (binDir </> "cabal" <> exeExt)
+      )
+      (throwE $ AlreadyInstalled Cabal ver)
 
   -- download (or use cached version)
   dl <- liftE $ downloadCached dlinfo Nothing
@@ -456,37 +420,30 @@ installCabalBindist dlinfo ver isoFilepath = do
   -- the subdir of the archive where we do the work
   workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
 
-  case isoFilepath of
-    Just isoDir -> do             -- isolated install
-      lift $ $(logInfo) [i|isolated installing Cabal to #{isoDir}|]
-      liftE $ installCabalUnpacked workdir isoDir Nothing
+  liftE $ installCabal' workdir binDir
 
-    Nothing -> do                 -- regular install
-      liftE $ installCabalUnpacked workdir binDir (Just ver)
+  -- create symlink if this is the latest version
+  cVers <- lift $ fmap rights getInstalledCabals
+  let lInstCabal = headMay . reverse . sort $ cVers
+  when (maybe True (ver >=) lInstCabal) $ liftE $ setCabal ver
 
-      -- create symlink if this is the latest version for regular installs
-      cVers <- lift $ fmap rights getInstalledCabals
-      let lInstCabal = headMay . reverse . sort $ cVers
-      when (maybe True (ver >=) lInstCabal) $ liftE $ setCabal ver
+ where
+  -- | Install an unpacked cabal distribution.
+  installCabal' :: (MonadLogger m, MonadCatch m, MonadIO m)
+                => FilePath      -- ^ Path to the unpacked cabal bindist (where the executable resides)
+                -> FilePath      -- ^ Path to install to
+                -> Excepts '[CopyError] m ()
+  installCabal' path inst = do
+    lift $ $(logInfo) "Installing cabal"
+    let cabalFile = "cabal"
+    liftIO $ createDirRecursive' inst
+    let destFileName = cabalFile <> "-" <> T.unpack (prettyVer ver) <> exeExt
+    let destPath = inst </> destFileName
+    handleIO (throwE . CopyError . show) $ liftIO $ copyFile
+      (path </> cabalFile <> exeExt)
+      destPath
+    lift $ chmod_755 destPath
 
--- | Install an unpacked cabal distribution.
-installCabalUnpacked :: (MonadLogger m, MonadCatch m, MonadIO m)
-              => FilePath      -- ^ Path to the unpacked cabal bindist (where the executable resides)
-              -> FilePath      -- ^ Path to install to
-              -> Maybe Version -- ^ Nothing for isolated install
-              -> Excepts '[CopyError, FileAlreadyExistsError] m ()
-installCabalUnpacked path inst mver' = do
-  lift $ $(logInfo) "Installing cabal"
-  let cabalFile = "cabal"
-  liftIO $ createDirRecursive' inst
-  let destFileName = cabalFile
-        <> maybe "" (("-" <>) . T.unpack . prettyVer) mver'
-        <> exeExt
-  let destPath = inst </> destFileName
-  handleIO (throwE . CopyError . show) $ liftIO $ copyFile
-    (path </> cabalFile <> exeExt)
-    destPath
-  lift $ chmod_755 destPath
 
 -- | Installs cabal into @~\/.ghcup\/bin/cabal-\<ver\>@ and
 -- creates a default @cabal -> cabal-x.y.z.q@ symlink for
@@ -505,7 +462,6 @@ installCabalBin :: ( MonadMask m
                    , MonadFail m
                    )
                 => Version
-                -> Maybe FilePath -- isolated install Path, if user provided any
                 -> Excepts
                      '[ AlreadyInstalled
                       , CopyError
@@ -518,13 +474,12 @@ installCabalBin :: ( MonadMask m
 #if !defined(TAR)
                       , ArchiveResult
 #endif
-                      , FileAlreadyExistsError
                       ]
                      m
                      ()
-installCabalBin ver isoFilepath = do
+installCabalBin ver = do
   dlinfo <- liftE $ getDownloadInfo Cabal ver
-  installCabalBindist dlinfo ver isoFilepath
+  installCabalBindist dlinfo ver
 
 
 -- | Like 'installHLSBin, except takes the 'DownloadInfo' as
@@ -543,7 +498,6 @@ installHLSBindist :: ( MonadMask m
                      )
                   => DownloadInfo
                   -> Version
-                  -> Maybe FilePath -- ^ isolated install path, if user passed any
                   -> Excepts
                        '[ AlreadyInstalled
                         , CopyError
@@ -559,19 +513,14 @@ installHLSBindist :: ( MonadMask m
                         ]
                        m
                        ()
-installHLSBindist dlinfo ver isoFilepath = do
+installHLSBindist dlinfo ver = do
   lift $ $(logDebug) [i|Requested to install hls version #{ver}|]
 
   PlatformRequest {..} <- lift getPlatformReq
   Dirs {..} <- lift getDirs
 
-  case isoFilepath of
-    Nothing ->
-      -- we only check for already installed in regular (non-isolated) installs
-      whenM (lift (hlsInstalled ver))
-      (throwE $ AlreadyInstalled HLS ver)
-
-    _ -> pure ()
+  whenM (lift (hlsInstalled ver))
+    (throwE $ AlreadyInstalled HLS ver)
 
   -- download (or use cached version)
   dl <- liftE $ downloadCached dlinfo Nothing
@@ -584,55 +533,46 @@ installHLSBindist dlinfo ver isoFilepath = do
   -- the subdir of the archive where we do the work
   workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
 
-  case isoFilepath of
-    Just isoDir -> do
-      lift $ $(logInfo) [i|isolated installing HLS to #{isoDir}|]
-      liftE $ installHLSUnpacked workdir isoDir Nothing
+  liftE $ installHLS' workdir binDir
 
-    Nothing -> do
-      liftE $ installHLSUnpacked workdir binDir (Just ver)
+  -- create symlink if this is the latest version
+  hlsVers <- lift $ fmap rights getInstalledHLSs
+  let lInstHLS = headMay . reverse . sort $ hlsVers
+  when (maybe True (ver >=) lInstHLS) $ liftE $ setHLS ver
 
-      -- create symlink if this is the latest version in a regular install
-      hlsVers <- lift $ fmap rights getInstalledHLSs
-      let lInstHLS = headMay . reverse . sort $ hlsVers
-      when (maybe True (ver >=) lInstHLS) $ liftE $ setHLS ver
+ where
+  -- | Install an unpacked hls distribution.
+  installHLS' :: (MonadFail m, MonadLogger m, MonadCatch m, MonadIO m)
+                => FilePath      -- ^ Path to the unpacked hls bindist (where the executable resides)
+                -> FilePath      -- ^ Path to install to
+                -> Excepts '[CopyError] m ()
+  installHLS' path inst = do
+    lift $ $(logInfo) "Installing HLS"
+    liftIO $ createDirRecursive' inst
 
+    -- install haskell-language-server-<ghcver>
+    bins@(_:_) <- liftIO $ findFiles
+      path
+      (makeRegexOpts compExtended
+                     execBlank
+                     ([s|^haskell-language-server-[0-9].*$|] :: ByteString)
+      )
+    forM_ bins $ \f -> do
+      let toF = dropSuffix exeExt f
+                <> "~" <> T.unpack (prettyVer ver) <> exeExt
+      handleIO (throwE . CopyError . show) $ liftIO $ copyFile
+        (path </> f)
+        (inst </> toF)
+      lift $ chmod_755 (inst </> toF)
 
--- | Install an unpacked hls distribution.
-installHLSUnpacked :: (MonadFail m, MonadLogger m, MonadCatch m, MonadIO m)
-              => FilePath      -- ^ Path to the unpacked hls bindist (where the executable resides)
-              -> FilePath      -- ^ Path to install to
-              -> Maybe Version -- ^ Nothing for isolated install
-              -> Excepts '[CopyError] m ()
-installHLSUnpacked path inst mver' = do
-  lift $ $(logInfo) "Installing HLS"
-  liftIO $ createDirRecursive' inst
-
-  -- install haskell-language-server-<ghcver>
-  bins@(_:_) <- liftIO $ findFiles
-    path
-    (makeRegexOpts compExtended
-                   execBlank
-                   ([s|^haskell-language-server-[0-9].*$|] :: ByteString)
-    )
-  forM_ bins $ \f -> do
-    let toF = dropSuffix exeExt f
-              <> maybe "" (("~" <>) . T.unpack . prettyVer) mver'
-              <> exeExt
+    -- install haskell-language-server-wrapper
+    let wrapper = "haskell-language-server-wrapper"
+        toF = wrapper <> "-" <> T.unpack (prettyVer ver) <> exeExt
     handleIO (throwE . CopyError . show) $ liftIO $ copyFile
-      (path </> f)
+      (path </> wrapper <> exeExt)
       (inst </> toF)
     lift $ chmod_755 (inst </> toF)
 
-  -- install haskell-language-server-wrapper
-  let wrapper = "haskell-language-server-wrapper"
-      toF = wrapper
-            <> maybe "" (("-" <>) . T.unpack . prettyVer) mver'
-            <> exeExt
-  handleIO (throwE . CopyError . show) $ liftIO $ copyFile
-    (path </> wrapper <> exeExt)
-    (inst </> toF)
-  lift $ chmod_755 (inst </> toF)
 
 -- | Installs hls binaries @haskell-language-server-\<ghcver\>@
 -- into @~\/.ghcup\/bin/@, as well as @haskell-languager-server-wrapper@.
@@ -650,7 +590,6 @@ installHLSBin :: ( MonadMask m
                  , MonadFail m
                  )
               => Version
-              -> Maybe FilePath
               -> Excepts
                    '[ AlreadyInstalled
                     , CopyError
@@ -666,9 +605,9 @@ installHLSBin :: ( MonadMask m
                     ]
                    m
                    ()
-installHLSBin ver isoFilepath = do
+installHLSBin ver = do
   dlinfo <- liftE $ getDownloadInfo HLS ver
-  installHLSBindist dlinfo ver isoFilepath
+  installHLSBindist dlinfo ver
 
 
 -- | Installs stack into @~\/.ghcup\/bin/stack-\<ver\>@ and
@@ -688,7 +627,6 @@ installStackBin :: ( MonadMask m
                    , MonadFail m
                    )
                 => Version
-                -> Maybe FilePath
                 -> Excepts
                      '[ AlreadyInstalled
                       , CopyError
@@ -704,9 +642,9 @@ installStackBin :: ( MonadMask m
                       ]
                      m
                      ()
-installStackBin ver isoFilepath = do
+installStackBin ver = do
   dlinfo <- liftE $ getDownloadInfo Stack ver
-  installStackBindist dlinfo ver isoFilepath
+  installStackBindist dlinfo ver
 
 
 -- | Like 'installStackBin', except takes the 'DownloadInfo' as
@@ -725,7 +663,6 @@ installStackBindist :: ( MonadMask m
                        )
                     => DownloadInfo
                     -> Version
-                    -> Maybe FilePath
                     -> Excepts
                          '[ AlreadyInstalled
                           , CopyError
@@ -741,18 +678,14 @@ installStackBindist :: ( MonadMask m
                           ]
                          m
                          ()
-installStackBindist dlinfo ver isoFilepath = do
+installStackBindist dlinfo ver = do
   lift $ $(logDebug) [i|Requested to install stack version #{ver}|]
 
   PlatformRequest {..} <- lift getPlatformReq
   Dirs {..} <- lift getDirs
 
-  case isoFilepath of
-    Nothing ->             -- check previous versions in case of regular installs
-      whenM (lift (stackInstalled ver))
-      (throwE $ AlreadyInstalled Stack ver)
-
-    _ -> pure ()           -- don't do shit for isolates
+  whenM (lift (stackInstalled ver))
+    (throwE $ AlreadyInstalled Stack ver)
 
   -- download (or use cached version)
   dl <- liftE $ downloadCached dlinfo Nothing
@@ -765,37 +698,31 @@ installStackBindist dlinfo ver isoFilepath = do
   -- the subdir of the archive where we do the work
   workdir <- maybe (pure tmpUnpack) (liftE . intoSubdir tmpUnpack) (view dlSubdir dlinfo)
 
-  case isoFilepath of
-    Just isoDir -> do                 -- isolated install
-      lift $ $(logInfo) [i|isolated installing Stack to #{isoDir}|]
-      liftE $ installStackUnpacked workdir isoDir Nothing
-    Nothing -> do                     -- regular install
-      liftE $ installStackUnpacked workdir binDir (Just ver)
+  liftE $ installStack' workdir binDir
 
-      -- create symlink if this is the latest version and a regular install
-      sVers <- lift $ fmap rights getInstalledStacks
-      let lInstStack = headMay . reverse . sort $ sVers
-      when (maybe True (ver >=) lInstStack) $ liftE $ setStack ver
+  -- create symlink if this is the latest version
+  sVers <- lift $ fmap rights getInstalledStacks
+  let lInstStack = headMay . reverse . sort $ sVers
+  when (maybe True (ver >=) lInstStack) $ liftE $ setStack ver
+
+ where
+  -- | Install an unpacked stack distribution.
+  installStack' :: (MonadLogger m, MonadCatch m, MonadIO m)
+                => FilePath      -- ^ Path to the unpacked stack bindist (where the executable resides)
+                -> FilePath      -- ^ Path to install to
+                -> Excepts '[CopyError] m ()
+  installStack' path inst = do
+    lift $ $(logInfo) "Installing stack"
+    let stackFile = "stack"
+    liftIO $ createDirRecursive' inst
+    let destFileName = stackFile <> "-" <> T.unpack (prettyVer ver) <> exeExt
+    let destPath = inst </> destFileName
+    handleIO (throwE . CopyError . show) $ liftIO $ copyFile
+      (path </> stackFile <> exeExt)
+      destPath
+    lift $ chmod_755 destPath
 
 
--- | Install an unpacked stack distribution.
-installStackUnpacked :: (MonadLogger m, MonadCatch m, MonadIO m)
-              => FilePath      -- ^ Path to the unpacked stack bindist (where the executable resides)
-              -> FilePath      -- ^ Path to install to
-              -> Maybe Version -- ^ Nothing for isolated installs
-              -> Excepts '[CopyError] m ()
-installStackUnpacked path inst mver' = do
-  lift $ $(logInfo) "Installing stack"
-  let stackFile = "stack"
-  liftIO $ createDirRecursive' inst
-  let destFileName = stackFile
-                     <> maybe "" (("-" <>) .  T.unpack . prettyVer) mver'
-                     <> exeExt
-  let destPath = inst </> destFileName
-  handleIO (throwE . CopyError . show) $ liftIO $ copyFile
-    (path </> stackFile <> exeExt)
-    destPath
-  lift $ chmod_755 destPath
 
 
     ---------------------
@@ -1777,7 +1704,6 @@ compileGHC :: ( MonadMask m
            -> [Text]                   -- ^ additional args to ./configure
            -> Maybe String             -- ^ build flavour
            -> Bool
-           -> Maybe FilePath           -- ^ isolate dir
            -> Excepts
                 '[ AlreadyInstalled
                  , BuildFailed
@@ -1790,14 +1716,13 @@ compileGHC :: ( MonadMask m
                  , UnknownArchive
                  , TarDirDoesNotExist
                  , NotInstalled
-                 , DirNotEmpty
 #if !defined(TAR)
                  , ArchiveResult
 #endif
                  ]
                 m
                 GHCTargetVersion
-compileGHC targetGhc ov bstrap jobs mbuildConfig patchdir aargs buildFlavour hadrian isolateDir
+compileGHC targetGhc ov bstrap jobs mbuildConfig patchdir aargs buildFlavour hadrian
   = do
     PlatformRequest { .. } <- lift getPlatformReq
     GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
@@ -1867,18 +1792,12 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patchdir aargs buildFlavour had
     alreadyInstalled <- lift $ ghcInstalled installVer
     alreadySet <- fmap (== Just tver) $ lift $ ghcSet (_tvTarget tver)
     when alreadyInstalled $ do
-      case isolateDir of
-        Just isoDir ->
-          lift $ $(logWarn) [i|GHC #{prettyShow tver} already installed. Isolate installing to #{isoDir} |]
-        Nothing ->
-          lift $ $(logWarn) [i|GHC #{prettyShow tver} already installed. Will overwrite existing version.|]
+      lift $ $(logWarn) [i|GHC #{prettyShow tver} already installed. Will overwrite existing version.|]
       lift $ $(logWarn)
         "...waiting for 10 seconds before continuing, you can still abort..."
       liftIO $ threadDelay 10000000 -- give the user a sec to intervene
 
-    ghcdir <- case isolateDir of
-      Just isoDir -> pure isoDir
-      Nothing -> lift $ ghcupGHCDir installVer
+    ghcdir         <- lift $ ghcupGHCDir installVer
 
     bghc <- case bstrap of
       Right g    -> pure $ Right g
@@ -1895,14 +1814,9 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patchdir aargs buildFlavour had
         pure (b, bmk)
       )
 
-    case isolateDir of
-      Nothing ->
-        -- only remove old ghc in regular installs
-        when alreadyInstalled $ do
-          lift $ $(logInfo) [i|Deleting existing installation|]
-          liftE $ rmGHCVer tver
-          
-      _ -> pure ()
+    when alreadyInstalled $ do
+      lift $ $(logInfo) [i|Deleting existing installation|]
+      liftE $ rmGHCVer tver
 
     forM_ mBindist $ \bindist -> do
       liftE $ installPackedGHC bindist
@@ -1911,15 +1825,11 @@ compileGHC targetGhc ov bstrap jobs mbuildConfig patchdir aargs buildFlavour had
                                (tver ^. tvVersion)
 
     liftIO $ B.writeFile (ghcdir </> ghcUpSrcBuiltFile) bmk
-    
-    case isolateDir of
-      -- set and make symlinks for regular (non-isolated) installs
-      Nothing -> do
-        reThrowAll GHCupSetError $ postGHCInstall tver
-        -- restore
-        when alreadySet $ liftE $ void $ setGHC tver SetGHCOnly
-        
-      _ -> pure ()
+
+    reThrowAll GHCupSetError $ postGHCInstall tver
+
+    -- restore
+    when alreadySet $ liftE $ void $ setGHC tver SetGHCOnly
 
     pure tver
 
@@ -2279,7 +2189,6 @@ upgradeGHCup mtarget force' = do
     -------------
 
 
-
 -- | Creates @ghc-x.y.z@ and @ghc-x.y@ symlinks. This is used for
 -- both installing from source and bindist.
 postGHCInstall :: ( MonadReader env m

lib/GHCup/Download.hs

@@ -172,31 +172,21 @@ getBase :: ( MonadReader env m
         -> Excepts '[JSONError] m GHCupInfo
 getBase uri = do
   Settings { noNetwork } <- lift getSettings
-
-  -- try to download yaml... usually this writes it into cache dir,
-  -- but in some cases not (e.g. when using file://), so we honour
-  -- the return filepath, if any
-  mYaml <- if noNetwork && view (uriSchemeL' % schemeBSL') uri /= "file" -- for file://, let it fall through
-           then pure Nothing
-           else handleIO (\e -> warnCache (displayException e) >> pure Nothing)
-               . catchE @_ @_ @'[] (\e@(DownloadFailed _) -> warnCache (prettyShow e) >> pure Nothing)
-               . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed
-               . fmap Just
-               . smartDl
-               $ uri
-
-  -- if we didn't get a filepath from the download, use the cached yaml
-  actualYaml <- maybe (lift $ yamlFromCache uri) pure mYaml
-  lift $ $(logDebug) [i|Decoding yaml at: #{actualYaml}|]
-
+  yaml <- lift $ yamlFromCache uri
+  unless noNetwork $
+    handleIO (\e -> warnCache (displayException e))
+      . catchE @_ @_ @'[] (\e@(DownloadFailed _) -> warnCache (prettyShow e))
+      . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed
+      . smartDl
+      $ uri
   liftE
-    . onE_ (onError actualYaml)
+    . onE_ (onError yaml)
     . lEM' @_ @_ @'[JSONError] JSONDecodeError
     . fmap (first (\e -> [i|#{displayException e}
-Consider removing "#{actualYaml}" manually.|]))
+Consider removing "#{yaml}" manually.|]))
     . liftIO
     . Y.decodeFileEither
-    $ actualYaml
+    $ yaml
  where
   -- On error, remove the etags file and set access time to 0. This should ensure the next invocation
   -- may re-download and succeed.
@@ -231,32 +221,28 @@ Consider removing "#{actualYaml}" manually.|]))
                 , DigestError
                 ]
                m1
-               FilePath
+               ()
   smartDl uri' = do
     json_file <- lift $ yamlFromCache uri'
-    let scheme = view (uriSchemeL' % schemeBSL') uri'
     e <- liftIO $ doesFileExist json_file
     currentTime <- liftIO getCurrentTime
-    Dirs { cacheDir } <- lift getDirs
+    if e
+      then do
+        accessTime <- liftIO $ getAccessTime json_file
 
-       -- for local files, let's short-circuit and ignore access time
-    if | scheme == "file" -> liftE $ download uri' Nothing cacheDir Nothing True
-       | e -> do
-          accessTime <- liftIO $ getAccessTime json_file
-
-          -- access time won't work on most linuxes, but we can try regardless
-          if | ((utcTimeToPOSIXSeconds currentTime - utcTimeToPOSIXSeconds accessTime) > 300) ->
-                -- no access in last 5 minutes, re-check upstream mod time
-                dlWithMod currentTime json_file
-             | otherwise -> pure json_file
-       | otherwise -> dlWithMod currentTime json_file
+        -- access time won't work on most linuxes, but we can try regardless
+        when ((utcTimeToPOSIXSeconds currentTime - utcTimeToPOSIXSeconds accessTime) > 300) $
+          -- no access in last 5 minutes, re-check upstream mod time
+          dlWithMod currentTime json_file
+      else
+        dlWithMod currentTime json_file
    where
     dlWithMod modTime json_file = do
       let (dir, fn) = splitFileName json_file
       f <- liftE $ download uri' Nothing dir (Just fn) True
       liftIO $ setModificationTime f modTime
       liftIO $ setAccessTime f modTime
-      pure f
+ 
 
 
 getDownloadInfo :: ( MonadReader env m
@@ -318,25 +304,27 @@ download :: ( MonadReader env m
             )
          => URI
          -> Maybe T.Text      -- ^ expected hash
-         -> FilePath          -- ^ destination dir (ignored for file:// scheme)
+         -> FilePath          -- ^ destination dir
          -> Maybe FilePath    -- ^ optional filename
          -> Bool              -- ^ whether to read an write etags
          -> Excepts '[DigestError , DownloadFailed] m FilePath
 download uri eDigest dest mfn etags
   | scheme == "https" = dl
   | scheme == "http"  = dl
-  | scheme == "file"  = do
-      let destFile' = T.unpack . decUTF8Safe $ path
-      lift $ $(logDebug) [i|using local file: #{destFile'}|]
-      forM_ eDigest (liftE . flip checkDigest destFile')
-      pure destFile'
+  | scheme == "file"  = cp
   | otherwise = throwE $ DownloadFailed (variantFromValue UnsupportedScheme)
 
  where
   scheme = view (uriSchemeL' % schemeBSL') uri
+  cp     = do
+    -- destination dir must exist
+    liftIO $ createDirRecursive' dest
+    let fromFile = T.unpack . decUTF8Safe $ path
+    liftIO $ copyFile fromFile destFile
+    pure destFile
   dl = do
-    destFile <- liftE . reThrowAll @_ @_ @'[DownloadFailed] DownloadFailed $ getDestFile
-    lift $ $(logInfo) [i|downloading: #{uri'} as file #{destFile}|]
+    let uri' = decUTF8Safe (serializeURIRef' uri)
+    lift $ $(logInfo) [i|downloading: #{uri'}|]
 
     -- destination dir must exist
     liftIO $ createDirRecursive' dest
@@ -378,7 +366,7 @@ download uri eDigest dest mfn etags
                             _ -> liftE $ throwE @_ @'[DownloadFailed] (DownloadFailed (toVariantAt @0 (MalformedHeaders headers)
                               :: V '[MalformedHeaders]))
 
-                          writeEtags destFile (parseEtags headers)
+                          writeEtags (parseEtags headers)
                     else
                       liftE $ lEM @_ @'[ProcessError] $ exec "curl" 
                         (o' ++ ["-fL", "-o", destFile, T.unpack uri']) Nothing Nothing
@@ -395,13 +383,13 @@ download uri eDigest dest mfn etags
                         case _exitCode of
                           ExitSuccess -> do
                             liftIO $ copyFile destFileTemp destFile
-                            writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
+                            writeEtags (parseEtags (decUTF8Safe' _stdErr))
                           ExitFailure i'
                             | i' == 8
                             , Just _ <- find (T.pack "304 Not Modified" `T.isInfixOf`) . T.lines . decUTF8Safe' $ _stdErr
                                      -> do
                                           $logDebug "Not modified, skipping download"
-                                          writeEtags destFile (parseEtags (decUTF8Safe' _stdErr))
+                                          writeEtags (parseEtags (decUTF8Safe' _stdErr))
                             | otherwise -> throwE (NonZeroExit i' "wget" opts)
                       else do
                         let opts = o' ++ ["-O", destFileTemp , T.unpack uri']
@@ -416,10 +404,10 @@ download uri eDigest dest mfn etags
                       let addHeaders = maybe mempty (\etag -> M.fromList [ (mk . E.encodeUtf8 . T.pack $ "If-None-Match"
                                                                          , E.encodeUtf8 etag)]) metag
                       liftE
-                        $ catchE @HTTPNotModified @'[DownloadFailed] @'[] (\(HTTPNotModified etag) -> lift $ writeEtags destFile (pure $ Just etag))
+                        $ catchE @HTTPNotModified @'[DownloadFailed] @'[] (\(HTTPNotModified etag) -> lift $ writeEtags (pure $ Just etag))
                         $ do
                           r <- downloadToFile https host fullPath port destFile addHeaders
-                          writeEtags destFile (pure $ decUTF8Safe <$> getHeader r "etag")
+                          writeEtags (pure $ decUTF8Safe <$> getHeader r "etag")
                     else void $ liftE $ catchE @HTTPNotModified
                                         @'[DownloadFailed]
                                    (\e@(HTTPNotModified _) ->
@@ -432,18 +420,12 @@ download uri eDigest dest mfn etags
 
 
   -- Manage to find a file we can write the body into.
-  getDestFile :: Monad m => Excepts '[NoUrlBase] m FilePath
-  getDestFile = 
-    case mfn of
-        Just fn -> pure (dest </> fn)
-        Nothing
-          | let urlBase = T.unpack (decUTF8Safe (urlBaseName path))
-          , not (null urlBase) -> pure (dest </> urlBase)
-          -- TODO: remove this once we use hpath again
-          | otherwise -> throwE $ NoUrlBase uri'
+  destFile :: FilePath
+  destFile = maybe (dest </> T.unpack (decUTF8Safe (urlBaseName path)))
+                  (dest </>)
+                  mfn
 
   path = view pathL' uri
-  uri' = decUTF8Safe (serializeURIRef' uri)
 
   parseEtags :: (MonadLogger m, MonadIO m, MonadThrow m) => T.Text -> m (Maybe T.Text)
   parseEtags stderr = do
@@ -462,8 +444,8 @@ download uri eDigest dest mfn etags
         $logDebug "No etags header found"
         pure Nothing
 
-  writeEtags :: (MonadLogger m, MonadIO m, MonadThrow m) => FilePath -> m (Maybe T.Text) -> m ()
-  writeEtags destFile getTags = do
+  writeEtags :: (MonadLogger m, MonadIO m, MonadThrow m) => m (Maybe T.Text) -> m ()
+  writeEtags getTags = do
     getTags >>= \case
       Just t -> do
         $logDebug [i|Writing etagsFile #{(etagsFile destFile)}|]

lib/GHCup/Errors.hs

@@ -134,13 +134,6 @@ instance Pretty AlreadyInstalled where
   pPrint (AlreadyInstalled tool ver') =
     text [i|#{tool}-#{prettyShow ver'} is already installed|]
 
--- | The Directory is supposed to be empty, but wasn't.
-data DirNotEmpty = DirNotEmpty {path :: FilePath}
-
-instance Pretty DirNotEmpty where
-  pPrint (DirNotEmpty path) = do
-    text [i|The directory was expected to be empty, but isn't: #{path}|]
-
 -- | The tool is not installed. Some operations rely on a tool
 -- to be installed (such as setting the current GHC version).
 data NotInstalled = NotInstalled Tool GHCTargetVersion
@@ -175,16 +168,6 @@ instance Pretty FileDoesNotExistError where
   pPrint (FileDoesNotExistError file) =
     text [i|File "#{file}" does not exist.|]
 
--- | The file already exists
--- (e.g. when we use isolated installs with the same path).
--- (e.g. This is done to prevent any overwriting)
-data FileAlreadyExistsError = FileAlreadyExistsError FilePath
-  deriving Show
-
-instance Pretty FileAlreadyExistsError where
-  pPrint (FileAlreadyExistsError file) =
-    text [i|File "#{file}" Already exists.|]
-
 data TarDirDoesNotExist = TarDirDoesNotExist TarDir
   deriving Show
 
@@ -344,15 +327,6 @@ instance Pretty UnexpectedListLength where
 
 instance Exception UnexpectedListLength
 
-data NoUrlBase = NoUrlBase Text
-  deriving Show
-
-instance Pretty NoUrlBase where
-  pPrint (NoUrlBase url) =
-    text [i|Couldn't get a base filename from url #{url}|]
-
-instance Exception NoUrlBase
-
 
 
     ------------------------