Add RIO.PrettyPrint to Stack.Prelude

Also makes Error: S-6602 a pretty exception.

Also refactors some import lists, in passing, with a longer term view to a more consistent approach.

src/Data/Attoparsec/Args.hs

@@ -36,10 +36,11 @@ argsParser mode = many (P.skipSpace *> (quoted <|> unquoted)) <*
                   P.skipSpace <* (P.endOfInput <?> "unterminated string")
   where
     unquoted = P.many1 naked
-    quoted = P.char '"' *> string <* P.char '"'
-    string = many (case mode of
+    quoted = P.char '"' *> str <* P.char '"'
+    str = many ( case mode of
                      Escaping -> escaped <|> nonquote
-                     NoEscaping -> nonquote)
+                     NoEscaping -> nonquote
+               )
     escaped = P.char '\\' *> P.anyChar
     nonquote = P.satisfy (/= '"')
     naked = P.satisfy (not . flip elem ("\" " :: String))

src/Data/Attoparsec/Interpreter.hs

@@ -145,9 +145,9 @@ getInterpreterArgs file = do
 
     decodeError e =
       case e of
-        ParseError ctxs _ (Position line col _) ->
+        ParseError ctxs _ (Position l col _) ->
           if null ctxs
           then "Parse error"
           else ("Expecting " ++ intercalate " or " ctxs)
-          ++ " at line " ++ show line ++ ", column " ++ show col
+          ++ " at line " ++ show l ++ ", column " ++ show col
         DivergentParser -> "Divergent parser"

src/Network/HTTP/StackClient.hs

@@ -58,30 +58,44 @@ module Network.HTTP.StackClient
   , setForceDownload
   ) where
 
-import           Control.Monad.State (get, put, modify)
-import           Data.Aeson (FromJSON)
+import           Control.Monad.State ( get, put, modify )
+import           Data.Aeson ( FromJSON )
 import qualified Data.ByteString as Strict
-import           Data.Conduit (ConduitM, ConduitT, awaitForever, (.|), yield, await)
-import           Data.Conduit.Lift (evalStateC)
+import           Data.Conduit
+                   ( ConduitM, ConduitT, awaitForever, (.|), yield, await )
+import           Data.Conduit.Lift ( evalStateC )
 import qualified Data.Conduit.List as CL
-import           Data.Monoid (Sum (..))
+import           Data.Monoid ( Sum (..) )
 import qualified Data.Text as T
-import           Data.Time.Clock (NominalDiffTime, diffUTCTime, getCurrentTime)
-import           Network.HTTP.Client (Request, RequestBody(..), Response, parseRequest, getUri, path, checkResponse, parseUrlThrow)
-import           Network.HTTP.Simple (setRequestCheckStatus, setRequestMethod, setRequestBody, setRequestHeader, addRequestHeader, HttpException(..), getResponseBody, getResponseStatusCode, getResponseHeaders)
-import           Network.HTTP.Types (hAccept, hContentLength, hContentMD5, methodPut)
-import           Network.HTTP.Conduit (requestHeaders)
-import           Network.HTTP.Client.TLS (getGlobalManager, applyDigestAuth, displayDigestAuthException)
-import           Network.HTTP.Download hiding (download, redownload, verifiedDownload)
+import           Data.Time.Clock
+                   ( NominalDiffTime, diffUTCTime, getCurrentTime )
+import           Network.HTTP.Client
+                   ( Request, RequestBody (..), Response, parseRequest, getUri
+                   , path, checkResponse, parseUrlThrow
+                   )
+import           Network.HTTP.Simple
+                   ( setRequestCheckStatus, setRequestMethod, setRequestBody
+                   , setRequestHeader, addRequestHeader, HttpException (..)
+                   , getResponseBody, getResponseStatusCode, getResponseHeaders
+                   )
+import           Network.HTTP.Types
+                   ( hAccept, hContentLength, hContentMD5, methodPut )
+import           Network.HTTP.Conduit ( requestHeaders )
+import           Network.HTTP.Client.TLS
+                   ( getGlobalManager, applyDigestAuth
+                   , displayDigestAuthException
+                   )
+import           Network.HTTP.Download
+                   hiding ( download, redownload, verifiedDownload )
 import qualified Network.HTTP.Download as Download
 import qualified Network.HTTP.Simple
-import           Network.HTTP.Client.MultipartFormData (formDataBody, partFileRequestBody, partBS, partLBS)
+import           Network.HTTP.Client.MultipartFormData
+                   ( formDataBody, partFileRequestBody, partBS, partLBS )
 import           Path
-import           Prelude (until, (!!))
+import           Prelude ( until, (!!) )
 import           RIO
-import           RIO.PrettyPrint
-import           Text.Printf (printf)
-
+import           RIO.PrettyPrint ( HasTerm )
+import           Text.Printf ( printf )
 
 setUserAgent :: Request -> Request
 setUserAgent = setRequestHeader "User-Agent" ["The Haskell Stack"]

src/Options/Applicative/Args.hs

@@ -17,22 +17,22 @@ import           Stack.Prelude
 argsArgument :: O.Mod O.ArgumentFields [String] -> O.Parser [String]
 argsArgument =
     O.argument
-        (do string <- O.str
-            either O.readerError pure (parseArgsFromString Escaping string))
+        (do s <- O.str
+            either O.readerError pure (parseArgsFromString Escaping s))
 
 -- | An option which accepts a list of arguments e.g. @--ghc-options="-X P.hs \"this\""@.
 argsOption :: O.Mod O.OptionFields [String] -> O.Parser [String]
 argsOption =
     O.option
-        (do string <- O.str
-            either O.readerError pure (parseArgsFromString Escaping string))
+        (do s <- O.str
+            either O.readerError pure (parseArgsFromString Escaping s))
 
 -- | An option which accepts a command and a list of arguments e.g. @--exec "echo hello world"@
 cmdOption :: O.Mod O.OptionFields (String, [String]) -> O.Parser (String, [String])
 cmdOption =
     O.option
-        (do string <- O.str
-            xs <- either O.readerError pure (parseArgsFromString Escaping string)
+        (do s <- O.str
+            xs <- either O.readerError pure (parseArgsFromString Escaping s)
             case xs of
                 [] -> O.readerError "Must provide a command"
                 x:xs' -> pure (x, xs'))

src/Path/CheckInstall.hs

@@ -4,10 +4,9 @@
 
 module Path.CheckInstall where
 
-import           Control.Monad.Extra (anyM, (&&^))
+import           Control.Monad.Extra ( anyM, (&&^) )
 import qualified Data.Text as T
 import           Stack.Prelude
-import           RIO.PrettyPrint
 import           Stack.Types.Config
 import qualified System.Directory as D
 import qualified System.FilePath as FP

src/Stack/Build/ConstructPlan.hs

@@ -13,41 +13,41 @@ module Stack.Build.ConstructPlan
     ( constructPlan
     ) where
 
-import           Stack.Prelude hiding (Display (..), loadPackage)
-import           Control.Monad.RWS.Strict hiding ((<>))
-import           Control.Monad.State.Strict (execState)
+import           Control.Monad.RWS.Strict hiding ( (<>) )
+import           Control.Monad.State.Strict ( execState )
 import qualified Data.List as L
 import qualified Data.Map.Strict as M
 import qualified Data.Map.Strict as Map
-import           Data.Monoid.Map (MonoidMap(..))
+import           Data.Monoid.Map ( MonoidMap(..) )
 import qualified Data.Set as Set
 import qualified Data.Text as T
-import           Distribution.Types.BuildType (BuildType (Configure))
-import           Distribution.Types.PackageName (mkPackageName)
-import           Generics.Deriving.Monoid (memptydefault, mappenddefault)
-import           Path (parent)
+import           Distribution.Types.BuildType ( BuildType (Configure) )
+import           Distribution.Types.PackageName ( mkPackageName )
+import           Generics.Deriving.Monoid ( memptydefault, mappenddefault )
+import           Path ( parent )
 import qualified RIO
+import           RIO.Process ( findExecutable, HasProcessContext (..) )
 import           Stack.Build.Cache
 import           Stack.Build.Haddock
 import           Stack.Build.Installed
 import           Stack.Build.Source
 import           Stack.Constants
 import           Stack.Package
 import           Stack.PackageDump
+import           Stack.Prelude hiding ( Display (..), loadPackage )
 import           Stack.SourceMap
 import           Stack.Types.Build
 import           Stack.Types.Compiler
 import           Stack.Types.Config
+import           Stack.Types.Dependency
+                   ( DepValue (DepValue), DepType (AsLibrary) )
 import           Stack.Types.GhcPkgId
 import           Stack.Types.NamedComponent
 import           Stack.Types.Package
 import           Stack.Types.SourceMap
 import           Stack.Types.Version
-import           System.Environment (lookupEnv)
-import           System.IO (putStrLn)
-import           RIO.PrettyPrint
-import           RIO.Process (findExecutable, HasProcessContext (..))
-import           Stack.Types.Dependency (DepValue(DepValue), DepType (AsLibrary))
+import           System.Environment ( lookupEnv )
+import           System.IO ( putStrLn )
 
 data PackageInfo
     =

src/Stack/Build/Execute.hs

@@ -24,48 +24,51 @@ module Stack.Build.Execute
     ) where
 
 import           Control.Concurrent.Execute
-import           Control.Concurrent.STM (check)
-import           Stack.Prelude hiding (Display (..))
+import           Control.Concurrent.STM ( check )
 import           Crypto.Hash
-import           Data.Attoparsec.Text hiding (try)
-import qualified Data.ByteArray as Mem (convert)
+import           Data.Attoparsec.Text as P hiding ( try )
+import qualified Data.ByteArray as Mem ( convert )
 import qualified Data.ByteString as S
 import qualified Data.ByteString.Builder
 import qualified Data.ByteString.Lazy as BL
 import qualified Data.ByteString.Base64.URL as B64URL
-import           Data.Char (isSpace)
+import           Data.Char ( isSpace )
 import           Conduit
 import qualified Data.Conduit.Binary as CB
 import qualified Data.Conduit.Filesystem as CF
 import qualified Data.Conduit.List as CL
-import           Data.Conduit.Process.Typed (createSource)
+import           Data.Conduit.Process.Typed ( createSource )
 import qualified Data.Conduit.Text as CT
 import qualified Data.List as L
-import           Data.List.NonEmpty (nonEmpty)
-import qualified Data.List.NonEmpty as NonEmpty (toList)
-import           Data.List.Split (chunksOf)
+import           Data.List.NonEmpty ( nonEmpty )
+import qualified Data.List.NonEmpty as NonEmpty ( toList )
+import           Data.List.Split ( chunksOf )
 import qualified Data.Map.Strict as M
 import qualified Data.Map.Strict as Map
 import qualified Data.Set as Set
 import qualified Data.Text as T
-import           Data.Text.Encoding (decodeUtf8)
+import           Data.Text.Encoding ( decodeUtf8 )
 import           Data.Tuple
-import           Data.Time (ZonedTime, getZonedTime, formatTime, defaultTimeLocale)
+import           Data.Time
+                   ( ZonedTime, getZonedTime, formatTime, defaultTimeLocale )
 import qualified Data.ByteString.Char8 as S8
 import qualified Distribution.PackageDescription as C
 import qualified Distribution.Simple.Build.Macros as C
-import           Distribution.System            (OS (Windows),
-                                                 Platform (Platform))
+import           Distribution.System ( OS (Windows), Platform (Platform) )
 import qualified Distribution.Text as C
-import           Distribution.Types.PackageName (mkPackageName)
-import           Distribution.Types.UnqualComponentName (mkUnqualComponentName)
-import           Distribution.Verbosity (showForCabal)
-import           Distribution.Version (mkVersion)
+import           Distribution.Types.PackageName ( mkPackageName )
+import           Distribution.Types.UnqualComponentName
+                   ( mkUnqualComponentName )
+import           Distribution.Verbosity ( showForCabal )
+import           Distribution.Version ( mkVersion )
+import           Pantry.Internal.Companion
 import           Path
 import           Path.CheckInstall
-import           Path.Extra (toFilePathNoTrailingSep, rejectMissingFile)
-import           Path.IO hiding (findExecutable, makeAbsolute, withSystemTempDir)
+import           Path.Extra ( toFilePathNoTrailingSep, rejectMissingFile )
+import           Path.IO
+                   hiding ( findExecutable, makeAbsolute, withSystemTempDir )
 import qualified RIO
+import           RIO.Process
 import           Stack.Build.Cache
 import           Stack.Build.Haddock
 import           Stack.Build.Installed
@@ -75,10 +78,11 @@ import           Stack.Config
 import           Stack.Constants
 import           Stack.Constants.Config
 import           Stack.Coverage
-import           Stack.DefaultColorWhen (defaultColorWhen)
+import           Stack.DefaultColorWhen ( defaultColorWhen )
 import           Stack.GhcPkg
 import           Stack.Package
 import           Stack.PackageDump
+import           Stack.Prelude hiding ( Display (..) )
 import           Stack.Types.Build
 import           Stack.Types.Compiler
 import           Stack.Types.Config
@@ -88,15 +92,16 @@ import           Stack.Types.Package
 import           Stack.Types.PackageFile
 import           Stack.Types.Version
 import qualified System.Directory as D
-import           System.Environment (getExecutablePath, lookupEnv)
-import           System.FileLock (withTryFileLock, SharedExclusive (Exclusive), withFileLock)
+import           System.Environment ( getExecutablePath, lookupEnv )
+import           System.FileLock
+                   ( withTryFileLock, SharedExclusive (Exclusive)
+                   , withFileLock
+                   )
 import qualified System.FilePath as FP
-import           System.IO.Error (isDoesNotExistError)
-import           System.PosixCompat.Files (createLink, modificationTime, getFileStatus)
-import           RIO.PrettyPrint
-import           RIO.Process
-import           Pantry.Internal.Companion
-import           System.Random (randomIO)
+import           System.IO.Error ( isDoesNotExistError )
+import           System.PosixCompat.Files
+                   ( createLink, modificationTime, getFileStatus )
+import           System.Random ( randomIO )
 
 -- | Has an executable been built or not?
 data ExecutableBuildStatus
@@ -2193,7 +2198,7 @@ mungeBuildOutput excludeTHLoading makeAbsolute pkgDir compilerVer = void $
     lineCol = char ':'
            >> choice
                 [ num >> char ':' >> num >> optional (char '-' >> num) >> pure ()
-                , char '(' >> num >> char ',' >> num >> string ")-(" >> num >> char ',' >> num >> char ')' >> pure ()
+                , char '(' >> num >> char ',' >> num >> P.string ")-(" >> num >> char ',' >> num >> char ')' >> pure ()
                 ]
            >> char ':'
            >> pure ()

src/Stack/Build/Haddock.hs

@@ -16,26 +16,25 @@ module Stack.Build.Haddock
     , shouldHaddockDeps
     ) where
 
-import           Stack.Prelude
 import qualified Data.Foldable as F
 import qualified Data.HashSet as HS
 import qualified Data.Map.Strict as Map
 import qualified Data.Set as Set
-import           Data.Time (UTCTime)
+import           Data.Time ( UTCTime )
 import           Path
 import           Path.Extra
 import           Path.IO
-import           RIO.List (intercalate)
-import           RIO.PrettyPrint
+import           RIO.List ( intercalate )
+import           RIO.Process
 import           Stack.Constants
 import           Stack.PackageDump
+import           Stack.Prelude
 import           Stack.Types.Build
 import           Stack.Types.Config
 import           Stack.Types.GhcPkgId
 import           Stack.Types.Package
 import qualified System.FilePath as FP
-import           RIO.Process
-import           Web.Browser (openBrowser)
+import           Web.Browser ( openBrowser )
 
 openHaddocksInBrowser
     :: HasTerm env

src/Stack/BuildPlan.hs

@@ -421,13 +421,13 @@ selectBestSnapshot pkgDirs snaps = do
 
         reportResult r@BuildPlanCheckPartial {} loc = do
             logWarn $ "* Partially matches " <> RIO.display loc
-            logWarn $ RIO.display $ indent $ T.pack $ show r
+            logWarn $ RIO.display $ ind $ T.pack $ show r
 
         reportResult r@BuildPlanCheckFail {} loc = do
             logWarn $ "* Rejected " <> RIO.display loc
-            logWarn $ RIO.display $ indent $ T.pack $ show r
+            logWarn $ RIO.display $ ind $ T.pack $ show r
 
-        indent t = T.unlines $ fmap ("    " <>) (T.lines t)
+        ind t = T.unlines $ fmap ("    " <>) (T.lines t)
 
 showItems :: [String] -> Text
 showItems items = T.concat (map formatItem items)

src/Stack/ComponentFile.hs

@@ -31,7 +31,9 @@ import           Distribution.ModuleName ( ModuleName )
 import qualified Distribution.ModuleName as Cabal
 import           Distribution.Package
                    hiding
-                     ( Package, PackageIdentifier, packageName, packageVersion )
+                     ( Module, Package, PackageIdentifier, packageName
+                     , packageVersion
+                     )
 import           Distribution.PackageDescription hiding ( FlagName )
 import           Distribution.Text ( display )
 import           Distribution.Utils.Path ( getSymbolicPath )
@@ -40,8 +42,6 @@ import qualified HiFileParser as Iface
 import           Path as FL hiding ( replaceExtension )
 import           Path.Extra
 import           Path.IO hiding ( findFiles )
-import           RIO.PrettyPrint
-import qualified RIO.PrettyPrint as PP ( Style (Module) )
 import           Stack.Constants
 import           Stack.Prelude hiding ( Display (..) )
 import           Stack.Types.Config
@@ -395,7 +395,7 @@ logPossibilities dirs mn = do
   possibilities <- liftM concat (makePossibilities mn)
   unless (null possibilities) $ prettyWarnL
     [ flow "Unable to find a known candidate for the Cabal entry"
-    , (style PP.Module . fromString $ display mn) <> ","
+    , (style Module . fromString $ display mn) <> ","
     , flow "but did find:"
     , line <> bulletedList (map pretty possibilities)
     , flow "If you are using a custom preprocessor for this module"