Fix darwin aarch64 release

.gitlab-ci.yml

@@ -424,9 +424,15 @@ release:darwin:aarch64:
         -I nixpkgs=https://github.com/angerman/nixpkgs/archive/75f7281738b.tar.gz \
         --argstr system "aarch64-darwin" \
         --pure \
-        --keep CI_PROJECT_DIR --keep MAKE_ARGS --keep HADRIAN_ARGS --keep CABAL_CACHE \
+        --keep CI_PROJECT_DIR \
         --keep MACOSX_DEPLOYMENT_TARGET \
-        --keep JSON_VERSION --keep ARTIFACT \
+        --keep JSON_VERSION \
+        --keep ARTIFACT \
+        --keep OS \
+        --keep ARCH \
+        --keep CABAL_DIR \
+        --keep GHC_VERSION \
+        --keep CABAL_VERSION \
         --run "$1" 2>&1
     }
     runInNixShell ./.gitlab/before_script/darwin/install_deps.sh 2>&1

.gitlab/script/ghcup_version.sh

@@ -84,10 +84,8 @@ ghcup-gen check -f ghcup-${JSON_VERSION}.yaml
 eghcup --numeric-version
 
 eghcup install ${GHC_VERSION}
-[ `$(eghcup whereis ghc ${GHC_VERSION}) --numeric-version` = "${GHC_VERSION}" ]
 eghcup set ${GHC_VERSION}
 eghcup install-cabal ${CABAL_VERSION}
-[ `$(eghcup whereis cabal ${CABAL_VERSION}) --numeric-version` = "${CABAL_VERSION}" ]
 
 cabal --version
 
@@ -127,10 +125,10 @@ else
 
 	if [ "${OS}" = "DARWIN" ] ; then
 		eghcup install hls
-		$(eghcup whereis hls) --version
+		haskell-language-server-wrapper --version
 
 		eghcup install stack
-		$(eghcup whereis stack) --version
+		stack --version
 	elif [ "${OS}" = "LINUX" ] ; then
 		if [ "${ARCH}" = "64" ] ; then
 			eghcup install hls

app/ghcup/Main.hs

@@ -100,7 +100,6 @@ data Command
   | Rm (Either RmCommand RmOptions)
   | DInfo
   | Compile CompileCommand
-  | Whereis WhereisOptions WhereisCommand
   | Upgrade UpgradeOpts Bool
   | ToolRequirements
   | ChangeLog ChangeLogOptions
@@ -191,13 +190,6 @@ data ChangeLogOptions = ChangeLogOptions
   }
 
 
-data WhereisCommand = WhereisTool Tool (Maybe ToolVersion)
-
-data WhereisOptions = WhereisOptions {
-   directory :: Bool
-}
-
-
 -- https://github.com/pcapriotti/optparse-applicative/issues/148
 
 -- | A switch that can be enabled using --foo and disabled using --no-foo.
@@ -343,17 +335,6 @@ com =
            <$> info (compileP <**> helper)
                     (progDesc "Compile a tool from source")
            )
-      <> command
-           "whereis"
-            (info
-             (   (Whereis
-                     <$> (WhereisOptions <$> switch (short 'd' <> long "directory" <> help "return directory of the binary instead of the binary location"))
-                     <*> whereisP
-                 ) <**> helper
-             )
-             (progDesc "Find a tools location"
-             <> footerDoc ( Just $ text whereisFooter ))
-           )
       <> commandGroup "Main commands:"
       )
     <|> subparser
@@ -421,23 +402,6 @@ com =
   By default returns the URI of the ChangeLog of the latest GHC release.
   Pass '-o' to automatically open via xdg-open.|]
 
-  whereisFooter :: String
-  whereisFooter = [s|Discussion:
-  Finds the location of a tool. For GHC, this is the ghc binary, that
-  usually resides in a self-contained "~/.ghcup/ghc/<ghcver>" directory.
-  For cabal/stack/hls this the binary usually at "~/.ghcup/bin/<tool>-<ver>".
-
-Examples:
-  # outputs ~/.ghcup/ghc/8.10.5/bin/ghc.exe
-  ghcup whereis ghc 8.10.5
-  # outputs ~/.ghcup/ghc/8.10.5/bin/
-  ghcup whereis --directory ghc 8.10.5
-  # outputs ~/.ghcup/bin/cabal-3.4.0.0
-  ghcup whereis cabal 3.4.0.0
-  # outputs ~/.ghcup/bin/
-  ghcup whereis --directory cabal 3.4.0.0|]
-
-
 installCabalFooter :: String
 installCabalFooter = [s|Discussion:
   Installs the specified cabal-install version (or a recommended default one)
@@ -742,86 +706,6 @@ Examples:
   ghcup compile ghc -j 4 -v 8.4.2 -b 8.2.2 -x armv7-unknown-linux-gnueabihf --config $(pwd)/build.mk -- --enable-unregisterised|]
 
 
-whereisP :: Parser WhereisCommand
-whereisP = subparser
-  (  command
-      "ghc"
-      (WhereisTool GHC <$> info
-        ( optional (toolVersionArgument Nothing (Just GHC)) <**> helper )
-        ( progDesc "Get GHC location"
-        <> footerDoc (Just $ text whereisGHCFooter ))
-      )
-      <>
-     command
-      "cabal"
-      (WhereisTool Cabal <$> info
-        ( optional (toolVersionArgument Nothing (Just Cabal)) <**> helper )
-        ( progDesc "Get cabal location"
-        <> footerDoc (Just $ text whereisCabalFooter ))
-      )
-      <>
-     command
-      "hls"
-      (WhereisTool HLS <$> info
-        ( optional (toolVersionArgument Nothing (Just HLS)) <**> helper )
-        ( progDesc "Get HLS location"
-        <> footerDoc (Just $ text whereisHLSFooter ))
-      )
-      <>
-     command
-      "stack"
-      (WhereisTool Stack <$> info
-        ( optional (toolVersionArgument Nothing (Just Stack)) <**> helper )
-        ( progDesc "Get stack location"
-        <> footerDoc (Just $ text whereisStackFooter ))
-      )
-      <>
-     command
-      "ghcup"
-      (WhereisTool GHCup <$> info ( (pure Nothing) <**> helper ) ( progDesc "Get ghcup location" ))
-  )
- where
-  whereisGHCFooter = [s|Discussion:
-  Finds the location of a GHC executable, which usually resides in
-  a self-contained "~/.ghcup/ghc/<ghcver>" directory.
-
-Examples:
-  # outputs ~/.ghcup/ghc/8.10.5/bin/ghc.exe
-  ghcup whereis ghc 8.10.5
-  # outputs ~/.ghcup/ghc/8.10.5/bin/
-  ghcup whereis --directory ghc 8.10.5 |]
-
-  whereisCabalFooter = [s|Discussion:
-  Finds the location of a Cabal executable, which usually resides in
-  "~/.ghcup/bin/".
-
-Examples:
-  # outputs ~/.ghcup/bin/cabal-3.4.0.0
-  ghcup whereis cabal 3.4.0.0
-  # outputs ~/.ghcup/bin
-  ghcup whereis --directory cabal 3.4.0.0|]
-
-  whereisHLSFooter = [s|Discussion:
-  Finds the location of a HLS executable, which usually resides in
-  "~/.ghcup/bin/".
-
-Examples:
-  # outputs ~/.ghcup/bin/haskell-language-server-wrapper-1.2.0
-  ghcup whereis hls 1.2.0
-  # outputs ~/.ghcup/bin/
-  ghcup whereis --directory hls 1.2.0|]
-
-  whereisStackFooter = [s|Discussion:
-  Finds the location of a stack executable, which usually resides in
-  "~/.ghcup/bin/".
-
-Examples:
-  # outputs ~/.ghcup/bin/stack-2.7.1
-  ghcup whereis stack 2.7.1
-  # outputs ~/.ghcup/bin/
-  ghcup whereis --directory stack 2.7.1|]
-
-
 ghcCompileOpts :: Parser GHCCompileOptions
 ghcCompileOpts =
   GHCCompileOptions
@@ -1381,17 +1265,6 @@ Report bugs at <https://gitlab.haskell.org/haskell/ghcup-hs/issues>|]
 #endif
                       ]
 
-          let
-            runWhereIs =
-              runLogger
-                . flip runReaderT appstate
-                . runE
-                  @'[ NotInstalled
-                    , NoToolVersionSet
-                    , NextVerNotFound
-                    , TagNotFound
-                    ]
-
           let runUpgrade =
                 runLogger
                   . flip runReaderT appstate
@@ -1755,22 +1628,6 @@ Make sure to clean up #{tmpdir} afterwards.|])
                         runLogger $ $(logError) $ T.pack $ prettyShow e
                         pure $ ExitFailure 9
 
-            Whereis WhereisOptions{..} (WhereisTool tool whereVer) ->
-              runWhereIs (do
-                (v, _) <- liftE $ fromVersion whereVer tool
-                loc <- liftE $ whereIsTool tool v
-                if directory
-                then pure $ takeDirectory loc
-                else pure loc
-                )
-                >>= \case
-                      VRight r -> do
-                        putStr r
-                        pure ExitSuccess
-                      VLeft e -> do
-                        runLogger $ $(logError) $ T.pack $ prettyShow e
-                        pure $ ExitFailure 30
-
             Upgrade uOpts force -> do
               target <- case uOpts of
                 UpgradeInplace  -> Just <$> liftIO getExecutablePath

bootstrap-haskell

@@ -201,13 +201,10 @@ download_ghcup() {
 			;;
 	esac
 
-	edo mkdir -p "${GHCUP_DIR}"
+  edo mkdir -p "${GHCUP_DIR}"
-
-	# we may overwrite this in adjust_bashrc
 	cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
 		export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
 		EOF
-
 	# shellcheck disable=SC1090
     edo . "${GHCUP_DIR}"/env
     eghcup upgrade
@@ -241,49 +238,28 @@ adjust_bashrc() {
 
 	warn ""
 	warn "Detected ${MY_SHELL} shell on your system..."
-	warn "Do you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\"?"
+	warn "If you want ghcup to automatically add the required PATH variable to \"${GHCUP_PROFILE_FILE}\""
 	warn ""
-	warn "[P] Yes, prepend  [A] Yes, append  [N] No  [?] Help (default is \"P\")."
+	warn "[Y] Yes  [N] No  [?] Help (default is \"Y\")."
 	warn ""
 
 	while true; do
 		if [ -z "${BOOTSTRAP_HASKELL_NONINTERACTIVE}" ] ; then
 			read -r next_answer </dev/tty
 		else
-			next_answer="prepend"
+			next_answer="yes"
 		fi
 
-		case $next_answer in
-			[Pp]* | "")
-				cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-					export PATH="\$HOME/.cabal/bin:${GHCUP_BIN}:\$PATH"
-					EOF
-				;;
-			[Aa]*)
-				cat <<-EOF > "${GHCUP_DIR}"/env || die "Failed to create env file"
-					export PATH="\$HOME/.cabal/bin:\$PATH:${GHCUP_BIN}"
-					EOF
-				;;
-			*) ;;
-		esac
-
 		case $next_answer in
 			[Nn]*)
 				return ;;
-			[Pp]* | [Aa]* | "")
+			[Yy]* | "")
 				case $MY_SHELL in
 					"") break ;;
 					fish)
-						mkdir -p "${GHCUP_PROFILE_FILE%/*}"
+							mkdir -p "${GHCUP_PROFILE_FILE%/*}"
-						sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
+							sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
-						case $next_answer in
+							echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; test -f $GHCUP_DIR/env ; and set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-							[Pp]* | "")
-								echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin $GHCUP_BIN \$PATH # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-								;;
-							[Aa]*)
-								echo "set -q GHCUP_INSTALL_BASE_PREFIX[1]; or set GHCUP_INSTALL_BASE_PREFIX \$HOME ; set -gx PATH \$HOME/.cabal/bin \$PATH $GHCUP_BIN # ghcup-env" >> "${GHCUP_PROFILE_FILE}"
-								;;
-						esac
 						break ;;
 					bash)
 						sed -i -e '/# ghcup-env$/ s/^#*/#/' "${GHCUP_PROFILE_FILE}"
@@ -309,8 +285,7 @@ adjust_bashrc() {
 			*)
 				echo "Possible choices are:"
 				echo
-				echo "P - Yes, prepend to PATH, taking precedence (default)"
+				echo "Y - Yes, update my \"${GHCUP_PROFILE_FILE}\" (default)"
-				echo "A - Yes, append to PATH"
 				echo "N - No, don't mess with my configuration"
 				echo
 				echo "Please make your choice and press ENTER."

bootstrap-haskell.ps1

@@ -150,15 +150,6 @@ function Exec
 
 $ErrorActionPreference = 'Stop'
 
-$elevated = ([Security.Principal.WindowsPrincipal] `
- [Security.Principal.WindowsIdentity]::GetCurrent()
-).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator)
-
-if ($elevated) {
-  Print-Msg -color Yellow -msg ('This script should not be run as administrator/elevated. Waiting 10s before continuing anyway...')
-  Start-Sleep -s 10
-}
-
 $GhcupBasePrefixEnv = [System.Environment]::GetEnvironmentVariable('GHCUP_INSTALL_BASE_PREFIX', 'user')
 
 if ($GhcupBasePrefixEnv) {

ghcup-0.0.5.yaml

@@ -2060,8 +2060,8 @@ ghcupDownloads:
         A_ARM64:
           Linux_UnknownLinux:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-linux-ghcup-0.1.15.2-r1
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-linux-ghcup-0.1.15.2-r2
-              dlHash: d853372440f3d43babbb868fad399811241760f2233829c92403fcbea8c547ec
+              dlHash: d67702f7c9e3586e85ed7c1bd09b7544da55bd1d3b4a961a07018348f78cf76b
           Darwin:
             unknown_versioning:
               dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/aarch64-apple-darwin-ghcup-0.1.15.2
@@ -2069,8 +2069,8 @@ ghcupDownloads:
         A_ARM:
           Linux_UnknownLinux:
             unknown_versioning:
-              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/armv7-linux-ghcup-0.1.15.2-r1
+              dlUri: https://downloads.haskell.org/~ghcup/0.1.15.2/armv7-linux-ghcup-0.1.15.2
-              dlHash: f8add9b39e1f7d0f03904dc69a8683259972a4472432c1ade27d918c39a4a874
+              dlHash: 03a4af5ed895ada1dd21f4cc3f64dc9078a5bf4268313021d004c04bea7f9c2e
   HLS:
     1.1.0:
       viTags: []
@@ -2120,17 +2120,8 @@ ghcupDownloads:
         - old
       viChangeLog: https://github.com/commercialhaskell/stack/blob/master/ChangeLog.md#v251
       viPostInstall: &stack-post |
-        Stack manages GHC versions internally by default. In order to make it use ghcup installed
+        Stack manages GHC versions internally by default. In order to make it use ghcup installed GHC versions have a look at the options 'system-ghc', 'compiler-check' and 'compiler': https://docs.haskellstack.org/en/stable/yaml_configuration/#system-ghc
-        GHC versions you can run the following commands:
+        Additionally, you should upgrade stack only through ghcup.
-          stack config set install-ghc false --global
-          stack config set system-ghc  true  --global
-        
-        On windows, you may find the following config options useful too:
-          skip-msys, extra-path, extra-include-dirs, extra-lib-dirs
-
-        Also check out: https://docs.haskellstack.org/en/stable/yaml_configuration
-
-        !!! Additionally, you should upgrade stack only through ghcup and not use 'stack upgrade' !!!
       viArch:
         A_64:
           Linux_UnknownLinux:

lib/GHCup.hs

@@ -586,7 +586,7 @@ installStackBindist dlinfo ver = do
            , settings
            } <- lift ask
 
-  whenM (lift (stackInstalled ver))
+  whenM (lift (hlsInstalled ver))
     (throwE $ AlreadyInstalled Stack ver)
 
   -- download (or use cached version)
@@ -1880,49 +1880,3 @@ postGHCInstall ver@GHCTargetVersion {..} = do
     $ getMajorMinorV _tvVersion
   forM_ v' $ \(mj, mi) -> lift (getGHCForMajor mj mi _tvTarget)
     >>= mapM_ (\v -> liftE $ setGHC v SetGHC_XY)
-
-
--- | Reports the binary location of a given tool:
---
---   * for GHC, this reports: @~\/.ghcup\/ghc\/\<ver\>\/bin\/ghc@
---   * for cabal, this reports @~\/.ghcup\/bin\/cabal-\<ver\>@
---   * for hls, this reports @~\/.ghcup\/bin\/haskell-language-server-wrapper-\<ver\>@
---   * for stack, this reports @~\/.ghcup\/bin\/stack-\<ver\>@
---   * for ghcup, this reports the location of the currently running executable
-whereIsTool :: ( MonadReader AppState m
-               , MonadLogger m
-               , MonadThrow m
-               , MonadFail m
-               , MonadIO m
-               , MonadCatch m
-               , MonadMask m
-               , MonadUnliftIO m
-               )
-            => Tool
-            -> GHCTargetVersion
-            -> Excepts '[NotInstalled] m FilePath
-whereIsTool tool ver@GHCTargetVersion {..} = do
-  AppState { dirs } <- lift ask
-
-  case tool of
-    GHC -> do
-      whenM (lift $ fmap not $ ghcInstalled ver)
-        $ throwE (NotInstalled GHC ver)
-      bdir <- lift $ ghcupGHCDir ver
-      pure (bdir </> "bin" </> "ghc" <> exeExt)
-    Cabal -> do
-      whenM (lift $ fmap not $ cabalInstalled _tvVersion)
-        $ throwE (NotInstalled Cabal (GHCTargetVersion Nothing _tvVersion))
-      pure (binDir dirs </> "cabal-" <> T.unpack (prettyVer _tvVersion) <> exeExt)
-    HLS -> do
-      whenM (lift $ fmap not $ hlsInstalled _tvVersion)
-        $ throwE (NotInstalled HLS (GHCTargetVersion Nothing _tvVersion))
-      pure (binDir dirs </> "haskell-language-server-wrapper-" <> T.unpack (prettyVer _tvVersion) <> exeExt)
-
-    Stack -> do
-      whenM (lift $ fmap not $ stackInstalled _tvVersion)
-        $ throwE (NotInstalled Stack (GHCTargetVersion Nothing _tvVersion))
-      pure (binDir dirs </> "stack-" <> T.unpack (prettyVer _tvVersion) <> exeExt)
-    GHCup -> do
-      currentRunningExecPath <- liftIO getExecutablePath
-      liftIO $ canonicalizePath currentRunningExecPath

lib/GHCup/Utils/Logger.hs

@@ -20,7 +20,6 @@ import           GHCup.Utils.String.QQ
 import           Control.Monad
 import           Control.Monad.IO.Class
 import           Control.Monad.Logger
-import           Data.Char               ( ord )
 import           Prelude                 hiding ( appendFile )
 import           System.Console.Pretty
 import           System.FilePath
@@ -44,33 +43,20 @@ myLoggerT LoggerConfig {..} loggingt = runLoggingT loggingt mylogger
   mylogger :: Loc -> LogSource -> LogLevel -> LogStr -> IO ()
   mylogger _ _ level str' = do
     -- color output
-    let style' = case level of
-          LevelDebug   -> style Bold . color Blue
-          LevelInfo    -> style Bold . color Green
-          LevelWarn    -> style Bold . color Yellow
-          LevelError   -> style Bold . color Red
-          LevelOther _ -> id
     let l = case level of
-          LevelDebug   -> toLogStr (style' "[ Debug ]")
+          LevelDebug   -> toLogStr (style Bold $ color Blue "[ Debug ]")
-          LevelInfo    -> toLogStr (style' "[ Info  ]")
+          LevelInfo    -> toLogStr (style Bold $ color Green "[ Info  ]")
-          LevelWarn    -> toLogStr (style' "[ Warn  ]")
+          LevelWarn    -> toLogStr (style Bold $ color Yellow "[ Warn  ]")
-          LevelError   -> toLogStr (style' "[ Error ]")
+          LevelError   -> toLogStr (style Bold $ color Red "[ Error ]")
           LevelOther t -> toLogStr "[ " <> toLogStr t <> toLogStr " ]"
-    let strs = fmap toLogStr . B.split (fromIntegral $ ord '\n') . fromLogStr $ str'
+    let out = fromLogStr (l <> toLogStr " " <> str' <> toLogStr "\n")
-    let out = case strs of
-                [] -> B.empty
-                (x:xs) -> fromLogStr
-                  . foldr (\a b -> a <> toLogStr "\n" <> b) mempty
-                  . ((l <> toLogStr " " <> x) :)
-                  . fmap (\line' -> toLogStr (style' "[ ...   ] ") <> line' )
-                  $ xs
 
     when (lcPrintDebug || (not lcPrintDebug && (level /= LevelDebug)))
       $ colorOutter out
 
     -- raw output
     let lr = case level of
-          LevelDebug   -> toLogStr "Debug:"
+          LevelDebug   -> toLogStr "Debug: "
           LevelInfo    -> toLogStr "Info:"
           LevelWarn    -> toLogStr "Warn:"
           LevelError   -> toLogStr "Error:"