Make sure we source ghcup dirs in bootstrap script

Fixes #354

app/ghcup/BrickMain.hs

@@ -437,7 +437,6 @@ install' _ (_, ListResult {..}) = do
               , TarDirDoesNotExist
               , FileAlreadyExistsError
               , ProcessError
-              , GHCupShadowed
               ]
 
   run (do
@@ -453,7 +452,7 @@ install' _ (_, ListResult {..}) = do
           liftE $ installCabalBin lVer Nothing False $> (vi, dirs, ce)
         GHCup -> do
           let vi = snd <$> getLatest dls GHCup
-          liftE $ upgradeGHCup Nothing False False $> (vi, dirs, ce)
+          liftE $ upgradeGHCup Nothing False $> (vi, dirs, ce)
         HLS   -> do
           let vi = getVersionInfo lVer HLS dls
           liftE $ installHLSBin lVer Nothing False $> (vi, dirs, ce)

app/ghcup/GHCup/OptParse.hs

@@ -96,7 +96,7 @@ data Command
   | Config ConfigCommand
   | Whereis WhereisOptions WhereisCommand
 #ifndef DISABLE_UPGRADE
-  | Upgrade UpgradeOpts Bool Bool
+  | Upgrade UpgradeOpts Bool
 #endif
   | ToolRequirements ToolReqOpts
   | ChangeLog ChangeLogOptions
@@ -222,18 +222,18 @@ com =
            (info (List <$> listOpts <**> helper)
                  (progDesc "Show available GHCs and other tools")
            )
+#ifndef DISABLE_UPGRADE
       <> command
            "upgrade"
            (info
              (    (Upgrade <$> upgradeOptsP <*> switch
                     (short 'f' <> long "force" <> help "Force update")
-                    <*> switch
-                    (long "fail-if-shadowed" <> help "Fails after upgrading if the upgraded ghcup binary is shadowed by something else in PATH (useful for CI)")
                   )
              <**> helper
              )
              (progDesc "Upgrade ghcup")
            )
+#endif
       <> command
            "compile"
            (   Compile

app/ghcup/GHCup/OptParse/Compile.hs

@@ -283,7 +283,7 @@ hlsCompileOpts =
           (short 'g' <> long "git-ref" <> metavar "GIT_REFERENCE" <> help
             "The git commit/branch/ref to build from"
           ) <*>
-          optional (option str (short 'r' <> long "repository" <> metavar "GIT_REPOSITORY" <> help "The git repository to build from (defaults to HLS upstream)"
+          optional (option str (short 'r' <> long "repository" <> metavar "GIT_REPOSITORY" <> help "The git repository to build from (defaults to GHC upstream)"
             <> completer (gitFileUri ["https://github.com/haskell/haskell-language-server.git"])
           ))
           )))

app/ghcup/GHCup/OptParse/Upgrade.hs

@@ -59,16 +59,15 @@ data UpgradeOpts = UpgradeInplace
     --[ Parsers ]--
     ---------------
 
-
+          
 upgradeOptsP :: Parser UpgradeOpts
 upgradeOptsP =
   flag'
       UpgradeInplace
       (short 'i' <> long "inplace" <> help
-        "Upgrade ghcup in-place"
+        "Upgrade ghcup in-place (wherever it's at)"
       )
-    <|>
+    <|> (   UpgradeAt
-      (   UpgradeAt
         <$> option
               str
               (short 't' <> long "target" <> metavar "TARGET_DIR" <> help
@@ -93,7 +92,6 @@ type UpgradeEffects = '[ DigestError
                        , FileDoesNotExistError
                        , CopyError
                        , DownloadFailed
-                       , GHCupShadowed
                        ]
 
 
@@ -122,19 +120,18 @@ upgrade :: ( Monad m
            )
         => UpgradeOpts
         -> Bool
-        -> Bool
         -> Dirs
         -> (forall a. ReaderT AppState m (VEither UpgradeEffects a) -> m (VEither UpgradeEffects a))
         -> (ReaderT LeanAppState m () -> m ())
         -> m ExitCode
-upgrade uOpts force' fatal Dirs{..} runAppState runLogger = do
+upgrade uOpts force' Dirs{..} runAppState runLogger = do
   target <- case uOpts of
     UpgradeInplace  -> Just <$> liftIO getExecutablePath
     (UpgradeAt p)   -> pure $ Just p
     UpgradeGHCupDir -> pure (Just (binDir </> "ghcup" <> exeExt))
 
   runUpgrade runAppState (do
-    v' <- liftE $ upgradeGHCup target force' fatal
+    v' <- liftE $ upgradeGHCup target force'
     GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
     pure (v', dls)
     ) >>= \case

app/ghcup/Main.hs

@@ -141,7 +141,9 @@ main = do
         )
   let listCommands = infoOption
         ("install set rm install-cabal list"
+#ifndef DISABLE_UPGRADE
           <> " upgrade"
+#endif
           <> " compile debug-info tool-requirements changelog"
         )
         (  long "list-commands"
@@ -243,10 +245,14 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
                              alreadyInstalling' <- alreadyInstalling optCommand newTool
                              when (not alreadyInstalling') $
                                case t of
+#ifdef DISABLE_UPGRADE
+                                 GHCup -> pure ()
+#else
                                  GHCup -> runLogger $
                                             logWarn ("New GHCup version available: "
                                               <> prettyVer l
                                               <> ". To upgrade, run 'ghcup upgrade'")
+#endif
                                  _ -> runLogger $
                                         logWarn ("New "
                                           <> T.pack (prettyShow t)
@@ -290,24 +296,26 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
               s' <- appState
               liftIO $ brickMain s' >> pure ExitSuccess
 #endif
-            Install installCommand     -> install installCommand settings appState runLogger
+            Install installCommand   -> install installCommand settings appState runLogger
-            InstallCabalLegacy iopts   -> install (Left (InstallCabal iopts)) settings appState runLogger
+            InstallCabalLegacy iopts -> install (Left (InstallCabal iopts)) settings appState runLogger
-            Set setCommand             -> set setCommand runAppState runLeanAppState runLogger
+            Set setCommand           -> set setCommand runAppState runLeanAppState runLogger
-            UnSet unsetCommand         -> unset unsetCommand runLeanAppState runLogger
+            UnSet unsetCommand       -> unset unsetCommand runLeanAppState runLogger
-            List lo                    -> list lo no_color runAppState
+            List lo                  -> list lo no_color runAppState
-            Rm rmCommand               -> rm rmCommand runAppState runLogger
+            Rm rmCommand             -> rm rmCommand runAppState runLogger
-            DInfo                      -> dinfo runAppState runLogger
+            DInfo                    -> dinfo runAppState runLogger
-            Compile compileCommand     -> compile compileCommand settings dirs runAppState runLogger
+            Compile compileCommand   -> compile compileCommand settings dirs runAppState runLogger
-            Config configCommand       -> config configCommand settings keybindings runLogger
+            Config configCommand     -> config configCommand settings keybindings runLogger
             Whereis whereisOptions
-                    whereisCommand     -> whereis whereisCommand whereisOptions runAppState leanAppstate runLogger
+                    whereisCommand   -> whereis whereisCommand whereisOptions runAppState leanAppstate runLogger
-            Upgrade uOpts force' fatal -> upgrade uOpts force' fatal dirs runAppState runLogger
+#ifndef DISABLE_UPGRADE
-            ToolRequirements topts     -> toolRequirements topts runAppState runLogger
+            Upgrade uOpts force'     -> upgrade uOpts force' dirs runAppState runLogger
-            ChangeLog changelogOpts    -> changelog changelogOpts runAppState runLogger
+#endif
-            Nuke                       -> nuke appState runLogger
+            ToolRequirements topts   -> toolRequirements topts runAppState runLogger
-            Prefetch pfCom             -> prefetch pfCom runAppState runLogger
+            ChangeLog changelogOpts  -> changelog changelogOpts runAppState runLogger
-            GC gcOpts                  -> gc gcOpts runAppState runLogger
+            Nuke                     -> nuke appState runLogger
-            Run runCommand             -> run runCommand appState leanAppstate runLogger
+            Prefetch pfCom           -> prefetch pfCom runAppState runLogger
+            GC gcOpts                -> gc gcOpts runAppState runLogger
+            Run runCommand           -> run runCommand appState leanAppstate runLogger
 
           case res of
             ExitSuccess        -> pure ()
@@ -345,7 +353,9 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
     (HLS, ver)   = cmp' HLS (Just $ ToolVersion (mkTVer over)) ver
   alreadyInstalling (Compile (CompileHLS HLSCompileOptions{ targetHLS = Left tver }))
     (HLS, ver)   = cmp' HLS (Just $ ToolVersion (mkTVer tver)) ver
-  alreadyInstalling (Upgrade _ _ _) (GHCup, _) = pure True
+#ifndef DISABLE_UPGRADE
+  alreadyInstalling (Upgrade _ _) (GHCup, _) = pure True
+#endif
   alreadyInstalling _ _ = pure False
 
   cmp' :: ( HasLog env

docs/guide.md

@@ -57,13 +57,6 @@ as e.g. `/etc/bash_completion.d/ghcup` (depending on distro)
 and make sure your bashrc sources the startup script
 (`/usr/share/bash-completion/bash_completion` on some distros).
 
-## Portability
-
-`ghcup` is very portable. There are a few exceptions though:
-
-1. `ghcup tui` is only available on non-windows platforms
-2. legacy subcommands `ghcup install` (without a tool identifier) and `ghcup install-cabal` may be removed in the future
-
 # Configuration
 
 A configuration file can be put in `~/.ghcup/config.yaml`. The default config file

docs/steps.md

@@ -16,8 +16,6 @@ The Glorious Glasgow Haskell Compilation System, version 8.10.7
 If this fails, consult [the Getting started page](../install) for information on
 how to install Haskell on your computer.
 
-This guide is partly based on [Gil Mizrahi's blog](https://gilmi.me/blog/post/2021/08/14/hs-core-tools).
-
 ## Compiling programs with ghc
 
 Running `ghc` invokes the Glasgow Haskell Compiler (GHC), and can be used to
@@ -328,7 +326,6 @@ 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.tomsmeding.com/play" class="btn btn-primary" role="button">Online playground</a>
 </div>
 
 ## How to learn Haskell proper

ghcup.cabal

@@ -48,6 +48,13 @@ flag no-exe
   default:     False
   manual:      True
 
+flag disable-upgrade
+  description:
+    Disable upgrade functionality. This is mainly to support brew packagers.
+
+  default:     False
+  manual:      True
+
 library
   exposed-modules:
     GHCup
@@ -197,7 +204,6 @@ executable ghcup
     GHCup.OptParse.Set
     GHCup.OptParse.ToolRequirements
     GHCup.OptParse.UnSet
-    GHCup.OptParse.Upgrade
     GHCup.OptParse.Whereis
 
   hs-source-dirs:     app/ghcup
@@ -271,6 +277,11 @@ executable ghcup
   if flag(no-exe)
     buildable: False
 
+  if flag(disable-upgrade)
+    cpp-options: -DDISABLE_UPGRADE
+
+  else
+    other-modules: GHCup.OptParse.Upgrade
 
 test-suite ghcup-test
   type:               exitcode-stdio-1.0

lib/GHCup.hs

@@ -2587,7 +2587,6 @@ upgradeGHCup :: ( MonadMask m
              => Maybe FilePath    -- ^ full file destination to write ghcup into
              -> Bool              -- ^ whether to force update regardless
                                   --   of currently installed version
-             -> Bool              -- ^ whether to throw an error if ghcup is shadowed
              -> Excepts
                   '[ CopyError
                    , DigestError
@@ -2596,16 +2595,15 @@ upgradeGHCup :: ( MonadMask m
                    , DownloadFailed
                    , NoDownload
                    , NoUpdate
-                   , GHCupShadowed
                    ]
                   m
                   Version
-upgradeGHCup mtarget force' fatal = do
+upgradeGHCup mtarget force' = do
   Dirs {..} <- lift getDirs
   GHCupInfo { _ghcupDownloads = dls } <- lift getGHCupInfo
 
   lift $ logInfo "Upgrading GHCup..."
-  let latestVer = fst (fromJust (getLatest dls GHCup))
+  let latestVer = fromJust $ fst <$> getLatest dls GHCup
   (Just ghcupPVPVer) <- pure $ pvpToVersion ghcUpVer ""
   when (not force' && (latestVer <= ghcupPVPVer)) $ throwE NoUpdate
   dli   <- liftE $ getDownloadInfo GHCup latestVer
@@ -2627,18 +2625,15 @@ upgradeGHCup mtarget force' fatal = do
     lift $ logWarn $ T.pack (takeFileName destFile) <> " is not in PATH! You have to add it in order to use ghcup."
   liftIO (isShadowed destFile) >>= \case
     Nothing -> pure ()
-    Just pa
+    Just pa -> lift $ logWarn $ "ghcup is shadowed by "
-      | fatal -> throwE (GHCupShadowed pa destFile latestVer)
+      <> T.pack pa
-      | otherwise ->
+      <> ". The upgrade will not be in effect, unless you remove "
-        lift $ logWarn $ "ghcup is shadowed by "
+      <> T.pack pa
-          <> T.pack pa
+      <> " or make sure "
-          <> ". The upgrade will not be in effect, unless you remove "
+      <> T.pack destDir
-          <> T.pack pa
+      <> " comes before "
-          <> " or make sure "
+      <> T.pack (takeFileName pa)
-          <> T.pack destDir
+      <> " in PATH."
-          <> " comes before "
-          <> T.pack (takeDirectory pa)
-          <> " in PATH."
 
   pure latestVer
 

lib/GHCup/Errors.hs

@@ -27,7 +27,6 @@ import           Data.CaseInsensitive           ( CI )
 import           Data.Text                      ( Text )
 import           Data.Versions
 import           Haskus.Utils.Variant
-import           System.FilePath
 import           Text.PrettyPrint               hiding ( (<>) )
 import           Text.PrettyPrint.HughesPJClass hiding ( (<>) )
 import           URI.ByteString
@@ -292,24 +291,6 @@ instance Pretty HadrianNotFound where
   pPrint HadrianNotFound =
     text "Could not find Hadrian build files. Does this GHC version support Hadrian builds?"
 
-data GHCupShadowed = GHCupShadowed
-                       FilePath  -- shadow binary
-                       FilePath  -- upgraded binary
-                       Version   -- upgraded version
-  deriving Show
-
-instance Pretty GHCupShadowed where
-  pPrint (GHCupShadowed sh up _) =
-    text ("ghcup is shadowed by "
-         <> sh
-         <> ". The upgrade will not be in effect, unless you remove "
-         <> sh
-         <> " or make sure "
-         <> takeDirectory up
-         <> " comes before "
-         <> takeDirectory sh
-         <> " in PATH."
-         )
 
     -------------------------
     --[ High-level errors ]--

lib/GHCup/Utils.hs

@@ -317,10 +317,10 @@ ghcSet mtarget = do
            MP.setInput rest
            pure x
          )
-        <* MP.some pathSep
+        <* pathSep
         <* MP.takeRest
         <* MP.eof
-    ghcSubPath = MP.some pathSep <* MP.chunk "ghc" *> MP.some pathSep
+    ghcSubPath = pathSep <* MP.chunk "ghc" *> pathSep
 
 -- | Get all installed GHCs by reading ~/.ghcup/ghc/<dir>.
 -- If a dir cannot be parsed, returns left.
@@ -398,10 +398,10 @@ cabalSet = do
   cabalParse = MP.chunk "cabal-" *> version'
   -- parses any path component ending with path separator,
   -- e.g. "foo/"
-  stripPathComponet = parseUntil1 pathSep *> MP.some pathSep
+  stripPathComponet = parseUntil1 pathSep *> pathSep
   -- parses an absolute path up until the last path separator,
   -- e.g. "/bar/baz/foo" -> "/bar/baz/", leaving "foo"
-  stripAbsolutePath = MP.some pathSep *> MP.many (MP.try stripPathComponet)
+  stripAbsolutePath = pathSep *> MP.many (MP.try stripPathComponet)
   -- parses a relative path up until the last path separator,
   -- e.g. "bar/baz/foo" -> "bar/baz/", leaving "foo"
   stripRelativePath = MP.many (MP.try stripPathComponet)
@@ -492,10 +492,10 @@ stackSet = do
     cabalParse = MP.chunk "stack-" *> version'
     -- parses any path component ending with path separator,
     -- e.g. "foo/"
-    stripPathComponet = parseUntil1 pathSep *> MP.some pathSep
+    stripPathComponet = parseUntil1 pathSep *> pathSep
     -- parses an absolute path up until the last path separator,
     -- e.g. "/bar/baz/foo" -> "/bar/baz/", leaving "foo"
-    stripAbsolutePath = MP.some pathSep *> MP.many (MP.try stripPathComponet)
+    stripAbsolutePath = pathSep *> MP.many (MP.try stripPathComponet)
     -- parses a relative path up until the last path separator,
     -- e.g. "bar/baz/foo" -> "bar/baz/", leaving "foo"
     stripRelativePath = MP.many (MP.try stripPathComponet)
@@ -543,10 +543,10 @@ hlsSet = do
     cabalParse = MP.chunk "haskell-language-server-wrapper-" *> version'
     -- parses any path component ending with path separator,
     -- e.g. "foo/"
-    stripPathComponet = parseUntil1 pathSep *> MP.some pathSep
+    stripPathComponet = parseUntil1 pathSep *> pathSep
     -- parses an absolute path up until the last path separator,
     -- e.g. "/bar/baz/foo" -> "/bar/baz/", leaving "foo"
-    stripAbsolutePath = MP.some pathSep *> MP.many (MP.try stripPathComponet)
+    stripAbsolutePath = pathSep *> MP.many (MP.try stripPathComponet)
     -- parses a relative path up until the last path separator,
     -- e.g. "bar/baz/foo" -> "bar/baz/", leaving "foo"
     stripRelativePath = MP.many (MP.try stripPathComponet)

scripts/bootstrap/bootstrap-haskell

@@ -126,10 +126,10 @@ _eghcup() {
 	fi
     if [ -z "${BOOTSTRAP_HASKELL_VERBOSE}" ] ; then
         # shellcheck disable=SC2086
-        "${GHCUP_BIN}/ghcup" ${args} "$@"
+        "ghcup" ${args} "$@"
     else
         # shellcheck disable=SC2086
-        "${GHCUP_BIN}/ghcup" ${args} --verbose "$@"
+        "ghcup" ${args} --verbose "$@"
     fi
 }
 
@@ -228,99 +228,100 @@ posix_realpath() {
 }
 
 download_ghcup() {
+    if ! command -V "ghcup" >/dev/null 2>&1 ; then
+        case "${plat}" in
+            "linux"|"Linux")
+                case "${arch}" in
+                    x86_64|amd64)
+                        # we could be in a 32bit docker container, in which
+                        # case uname doesn't give us what we want
+                        if [ "$(getconf LONG_BIT)" = "32" ] ; then
+                            _url=${GHCUP_BASE_URL}/${ghver}/i386-linux-ghcup-${ghver}
+                        elif [ "$(getconf LONG_BIT)" = "64" ] ; then
+                            _url=${GHCUP_BASE_URL}/${ghver}/x86_64-linux-ghcup-${ghver}
+                        else
+                            die "Unknown long bit size: $(getconf LONG_BIT)"
+                        fi
+                        ;;
+                    i*86)
+                        _url=${GHCUP_BASE_URL}/${ghver}/i386-linux-ghcup-${ghver}
+                        ;;
+                    armv7*|*armv8l*)
+                        _url=${GHCUP_BASE_URL}/${ghver}/armv7-linux-ghcup-${ghver}
+                        ;;
+                    aarch64|arm64)
+                        # we could be in a 32bit docker container, in which
+                        # case uname doesn't give us what we want
+                        if [ "$(getconf LONG_BIT)" = "32" ] ; then
+                            _url=${GHCUP_BASE_URL}/${ghver}/armv7-linux-ghcup-${ghver}
+                        elif [ "$(getconf LONG_BIT)" = "64" ] ; then
+                            _url=${GHCUP_BASE_URL}/${ghver}/aarch64-linux-ghcup-${ghver}
+                        else
+                            die "Unknown long bit size: $(getconf LONG_BIT)"
+                        fi
+                        ;;
+                    *) die "Unknown architecture: ${arch}"
+                        ;;
+                esac
+                ;;
+            "FreeBSD"|"freebsd")
+                if freebsd-version | grep -E '^12.*' ; then
+                    freebsd_ver=12
+                elif freebsd-version | grep -E '^13.*' ; then
+                    freebsd_ver=13
+                else
+                    die "Unsupported FreeBSD version! Please report a bug at https://gitlab.haskell.org/haskell/ghcup-hs/-/issues"
+                fi
 
-    case "${plat}" in
+                case "${arch}" in
-        "linux"|"Linux")
+                    x86_64|amd64)
-			case "${arch}" in
+                        ;;
-				x86_64|amd64)
+                    i*86)
-					# we could be in a 32bit docker container, in which
+                        die "i386 currently not supported!"
-					# case uname doesn't give us what we want
+                        ;;
-					if [ "$(getconf LONG_BIT)" = "32" ] ; then
+                    *) die "Unknown architecture: ${arch}"
-						_url=${GHCUP_BASE_URL}/${ghver}/i386-linux-ghcup-${ghver}
+                        ;;
-					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
+                esac
-						_url=${GHCUP_BASE_URL}/${ghver}/x86_64-linux-ghcup-${ghver}
+                _url=${GHCUP_BASE_URL}/${ghver}/x86_64-freebsd${freebsd_ver}-ghcup-${ghver}
-					else
+                ;;
-						die "Unknown long bit size: $(getconf LONG_BIT)"
+            "Darwin"|"darwin")
-					fi
+                case "${arch}" in
-					;;
+                    x86_64|amd64)
-				i*86)
+                        _url=${GHCUP_BASE_URL}/${ghver}/x86_64-apple-darwin-ghcup-${ghver}
-					_url=${GHCUP_BASE_URL}/${ghver}/i386-linux-ghcup-${ghver}
+                        ;;
-					;;
+                    aarch64|arm64|armv8l)
-				armv7*|*armv8l*)
+                        _url=${GHCUP_BASE_URL}/${ghver}/aarch64-apple-darwin-ghcup-${ghver}
-					_url=${GHCUP_BASE_URL}/${ghver}/armv7-linux-ghcup-${ghver}
+                        ;;
-					;;
+                    i*86)
-				aarch64|arm64)
+                        die "i386 currently not supported!"
-					# we could be in a 32bit docker container, in which
+                        ;;
-					# case uname doesn't give us what we want
+                    *) die "Unknown architecture: ${arch}"
-					if [ "$(getconf LONG_BIT)" = "32" ] ; then
+                        ;;
-						_url=${GHCUP_BASE_URL}/${ghver}/armv7-linux-ghcup-${ghver}
+                esac
-					elif [ "$(getconf LONG_BIT)" = "64" ] ; then
+                ;;
-						_url=${GHCUP_BASE_URL}/${ghver}/aarch64-linux-ghcup-${ghver}
+            MSYS*|MINGW*)
-					else
+                case "${arch}" in
-						die "Unknown long bit size: $(getconf LONG_BIT)"
+                    x86_64|amd64)
-					fi
+                        _url=${GHCUP_BASE_URL}/${ghver}/x86_64-mingw64-ghcup-${ghver}.exe
-					;;
+                        ;;
-				*) die "Unknown architecture: ${arch}"
+                    *) die "Unknown architecture: ${arch}"
-					;;
+                        ;;
-			esac
+                esac
-			;;
+                ;;
-        "FreeBSD"|"freebsd")
+            *) die "Unknown platform: ${plat}"
-            if freebsd-version | grep -E '^12.*' ; then
+                ;;
-                freebsd_ver=12
+        esac
-            elif freebsd-version | grep -E '^13.*' ; then
+        case "${plat}" in
-                freebsd_ver=13
+            MSYS*|MINGW*)
-            else
+                edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup.exe
-                die "Unsupported FreeBSD version! Please report a bug at https://gitlab.haskell.org/haskell/ghcup-hs/-/issues"
+                edo chmod +x "${GHCUP_BIN}"/ghcup.exe
-            fi
+                ;;
-
+            *)
-			case "${arch}" in
+                edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup
-				x86_64|amd64)
+                edo chmod +x "${GHCUP_BIN}"/ghcup
-					;;
+                ;;
-				i*86)
+        esac
-					die "i386 currently not supported!"
+    fi
-					;;
-				*) die "Unknown architecture: ${arch}"
-					;;
-			esac
-			_url=${GHCUP_BASE_URL}/${ghver}/x86_64-freebsd${freebsd_ver}-ghcup-${ghver}
-            ;;
-        "Darwin"|"darwin")
-			case "${arch}" in
-				x86_64|amd64)
-					_url=${GHCUP_BASE_URL}/${ghver}/x86_64-apple-darwin-ghcup-${ghver}
-					;;
-				aarch64|arm64|armv8l)
-					_url=${GHCUP_BASE_URL}/${ghver}/aarch64-apple-darwin-ghcup-${ghver}
-					;;
-				i*86)
-					die "i386 currently not supported!"
-					;;
-				*) die "Unknown architecture: ${arch}"
-					;;
-			esac
-			;;
-        MSYS*|MINGW*)
-			case "${arch}" in
-				x86_64|amd64)
-					_url=${GHCUP_BASE_URL}/${ghver}/x86_64-mingw64-ghcup-${ghver}.exe
-					;;
-				*) die "Unknown architecture: ${arch}"
-					;;
-			esac
-			;;
-        *) die "Unknown platform: ${plat}"
-			;;
-    esac
-    case "${plat}" in
-        MSYS*|MINGW*)
-			edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup.exe
-			edo chmod +x "${GHCUP_BIN}"/ghcup.exe
-			;;
-		*)
-			edo curl -Lf "${_url}" > "${GHCUP_BIN}"/ghcup
-			edo chmod +x "${GHCUP_BIN}"/ghcup
-			;;
-	esac
 
 	edo mkdir -p "${GHCUP_DIR}"
 
@@ -344,7 +345,9 @@ download_ghcup() {
 
 	# shellcheck disable=SC1090
     edo . "${GHCUP_DIR}"/env
-    eghcup upgrade
+    if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
+        ghcup upgrade || yellow "Failed to upgrade ghcup, continuing anyway"
+    fi
 }
 
 # Figures out the users login shell and sets
@@ -733,13 +736,7 @@ fi
 
 edo mkdir -p "${GHCUP_BIN}"
 
-if command -V "ghcup" >/dev/null 2>&1 ; then
+download_ghcup
-    if [ -z "${BOOTSTRAP_HASKELL_NO_UPGRADE}" ] ; then
-        _eghcup upgrade || download_ghcup
-    fi
-else
-	download_ghcup
-fi
 
 echo
 if [ -n "${BOOTSTRAP_HASKELL_YAML}" ] ; then (>&2 ghcup -s "${BOOTSTRAP_HASKELL_YAML}" tool-requirements) ; else (>&2 ghcup tool-requirements) ; fi